
# import statement needed on some systems
import sys
import os.path
sys.path.append(os.path.dirname(__file__))

USE_LIBSBML_PYTHON_API2_WARNINGS = False
# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.12
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.

from sys import version_info as _swig_python_version_info
if _swig_python_version_info >= (2, 7, 0):
    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_libsbml')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_libsbml')
    _libsbml = swig_import_helper()
    del swig_import_helper
elif _swig_python_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
        try:
            _mod = imp.load_module('_libsbml', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _libsbml = swig_import_helper()
    del swig_import_helper
else:
    import _libsbml
del _swig_python_version_info

try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            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("'%s' object has no attribute '%s'" % (class_type.__name__, name))


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

try:
    _object = object
    _newclass = 1
except __builtin__.Exception:
    class _object:
        pass
    _newclass = 0

try:
    import weakref
    weakref_proxy = weakref.proxy
except __builtin__.Exception:
    weakref_proxy = lambda x: x


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 __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_ModelCreatorList
    __del__ = lambda self: None

    def add(self, item):
        return _libsbml.ModelCreatorList_add(self, item)

    def get(self, n):
        return _libsbml.ModelCreatorList_get(self, n)

    def prepend(self, item):
        return _libsbml.ModelCreatorList_prepend(self, item)

    def remove(self, n):
        return _libsbml.ModelCreatorList_remove(self, n)

    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 __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_DateList
    __del__ = lambda self: None

    def add(self, item):
        return _libsbml.DateList_add(self, item)

    def get(self, n):
        return _libsbml.DateList_get(self, n)

    def prepend(self, item):
        return _libsbml.DateList_prepend(self, item)

    def remove(self, n):
        return _libsbml.DateList_remove(self, n)

    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 __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_CVTermList
    __del__ = lambda self: None

    def add(self, item):
        return _libsbml.CVTermList_add(self, item)

    def get(self, n):
        return _libsbml.CVTermList_get(self, n)

    def prepend(self, item):
        return _libsbml.CVTermList_prepend(self, item)

    def remove(self, n):
        return _libsbml.CVTermList_remove(self, n)

    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 __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_ASTNodeList
    __del__ = lambda self: None

    def add(self, item):
        return _libsbml.ASTNodeList_add(self, item)

    def get(self, n):
        return _libsbml.ASTNodeList_get(self, n)

    def prepend(self, item):
        return _libsbml.ASTNodeList_prepend(self, item)

    def remove(self, n):
        return _libsbml.ASTNodeList_remove(self, n)

    def getSize(self):
        return _libsbml.ASTNodeList_getSize(self)
ASTNodeList_swigregister = _libsbml.ASTNodeList_swigregister
ASTNodeList_swigregister(ASTNodeList)

class SBMLNamespacesList(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLNamespacesList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SBMLNamespacesList, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _libsbml.new_SBMLNamespacesList()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_SBMLNamespacesList
    __del__ = lambda self: None

    def add(self, item):
        return _libsbml.SBMLNamespacesList_add(self, item)

    def get(self, n):
        return _libsbml.SBMLNamespacesList_get(self, n)

    def prepend(self, item):
        return _libsbml.SBMLNamespacesList_prepend(self, item)

    def remove(self, n):
        return _libsbml.SBMLNamespacesList_remove(self, n)

    def getSize(self):
        return _libsbml.SBMLNamespacesList_getSize(self)
SBMLNamespacesList_swigregister = _libsbml.SBMLNamespacesList_swigregister
SBMLNamespacesList_swigregister(SBMLNamespacesList)

class SBaseList(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SBaseList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SBaseList, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _libsbml.new_SBaseList()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_SBaseList
    __del__ = lambda self: None

    def add(self, item):
        return _libsbml.SBaseList_add(self, item)

    def get(self, n):
        return _libsbml.SBaseList_get(self, n)

    def prepend(self, item):
        return _libsbml.SBaseList_prepend(self, item)

    def remove(self, n):
        return _libsbml.SBaseList_remove(self, n)

    def getSize(self):
        return _libsbml.SBaseList_getSize(self)
SBaseList_swigregister = _libsbml.SBaseList_swigregister
SBaseList_swigregister(SBaseList)



## enable optional new API2 functionality by configure or environment
if 'USE_LIBSBML_PYTHON_API2_WARNINGS' in os.environ:
    try:
        _etest = int(os.environ['USE_LIBSBML_PYTHON_API2_WARNINGS'])
    except ValueError:
        _etest = 0
        print('\nThe environment variable "USE_LIBSBML_PYTHON_API2_WARNINGS" should have the value 1 or 0\n')

    if _etest:
        USE_LIBSBML_PYTHON_API2_WARNINGS = True
    else:
        USE_LIBSBML_PYTHON_API2_WARNINGS = False

# class decorator, from six, that will be used to solve Python2/3 metaclass issues
# usage is NewClass(with_metaclass(MetaClass, BaseClasses)):
#def with_metaclass(meta, *bases):
#    """Create a base class with a metaclass.
#Usage is: NewClass(with_metaclass(MetaClass, BaseClass*)"""
# This requires a bit of explanation: the basic idea is to make a dummy
# metaclass for one level of class instantiation that replaces itself with
# the actual metaclass.
#    class metaclass(type):
#
#        def __new__(cls, name, this_bases, d):
#            return meta(name, bases, d)
#
#        @classmethod
#        def __prepare__(cls, name, this_bases):
#            return meta.__prepare__(name, bases)
#    return type.__new__(metaclass, 'temporary_class', (), {})

if USE_LIBSBML_PYTHON_API2_WARNINGS:
    import warnings
    class PythonAPI2Warning(UserWarning):
        """ Custom warning class for warnings generated by libSBML Python API2. """

        def __init__(self, msg):
            """ x.__init__(...) initializes x; see help(type(x)) for signature """
            print(msg)

    def p_func_warning_decorator(F):
        try:
            incoming_name = F.__name__
        except:
            return F
        from functools import wraps
        @wraps(F)
        def warning_wrap(*args, **kwargs):
            res = msg = None
            res = F(*args, **kwargs)
            if type(res) == int and res < 0:
                msg = '\"{}\" returns an error ({}): {}'.format(incoming_name, res,\
                                            OperationReturnValue_toString(res))
                warnings.warn(msg, category=PythonAPI2Warning)
            return res
        return warning_wrap

class AutoProperty(type):
    """
    Auto-detect Python class getX/setX methods.

    This class is attached to SBase and automatically applies for all classes
    which inherit from it.  Its purpose is to make libSBML more convenient to
    use from Python.  It works by analyzing classes at class creation time
    (not at instantiation) and adding corresponding properties (directly
    calling C methods where possible) to the class dictionary.

    @note The code should work for python 2.6 upwards, however for python 3 it
          needs to be attached via constructors.
    """
    def __new__(cls, classname, bases, classdict):
        """
        Iterate over the items in the classdict looking for get/set pairs
        and declaring them as properties.
        """
        import re
        import keyword
        import sys
        if sys.version_info < (3, 0):
          from inspect import getargspec as mygetargspec
        else:
          from inspect import getfullargspec as mygetargspec

        re_mangle = re.compile(r'[A-Za-z][a-z]+|[A-Z]+(?=$|[A-Z0-9])|\d+')
        re_id = re.compile(r'^[A-Za-z_][A-Za-z0-9_]*$')
        re_getdoc = re.compile(r'^\s*[A-Za-z_][A-Za-z0-9_]*\(self\)')
        re_setdoc = re.compile(r'^\s*[A-Za-z_][A-Za-z0-9_]*\(self,[^,)]+\)')

#convert ACapitalCasedStringXYZ123 -> a_capital_cased_string_xyz_123
        mangle_name = lambda x: ('_'.join(re_mangle.findall(x))).lower()

        get_methods = set()
        set_methods = set()
        swig_setter = classdict.get('__swig_setmethods__', {})

        if USE_LIBSBML_PYTHON_API2_WARNINGS:
# explicitly collect unsetX methods separately for method decorator
            unset_methods = set()
# collect addX and methods for method decorator
            re_addfunc = re.compile(r'add[A-Z][A-Za-z0-9_]*')
            add_methods = set()

        allowed_methods = [
            'Annotation',
            'AnnotationString',
            'Notes',
            'NotesString',
        ]

#only search for get/set methods
#we assume that any unset method also has either get or set
#a small number of set without get cases exist so we can't only
#search for get methods
        for k, v in classdict.items():
            name = k[3:]
            prefix = k[:3]
            mangled = mangle_name(name)
            if name:
                if callable(v):
                    if re_id.match(mangled) and mangled not in keyword.kwlist:
                        if prefix == 'get':
                            get_methods.add(name)
                        elif prefix == 'set':
                            set_methods.add(name)
            if USE_LIBSBML_PYTHON_API2_WARNINGS:
# find addX methods for decoration
                if re_addfunc.match(k) is not None:
                    add_methods.add(k)

        for name in get_methods | set_methods:

            mangled = mangle_name(name)

#ListOfFoobars -> foobars
            if mangled.startswith('list_of_'):
                mangled = mangled[8:]

            getter = setter = deleter = None
            if name in get_methods:
                getter = classdict['get'+name]

#this is a very dirty way of checking if the get method
#requires extra arguments (and hence cannot be a property)
#it should be possible to do this properly in SWIG?
                try:
                    argspec = mygetargspec(getter)
                    numargs = len(argspec.args)
                    if numargs > 1 or (numargs == 1 and argspec.args[0] != 'self')  \
                       or (argspec.varargs!=None and name not in allowed_methods and not name.startswith('ListOf') ):
                        continue
                except Exception:
                    continue

#use the c-level get function if the python function
#only consists of a call to it
                cname = classname + '_get' + name
#test if function is "return _libsbml.CLASS_getNAME(__args__)"
                try:
                    if getter.func_code.co_names == ('_libsbml', cname):
                        getter = getattr(_libsbml, cname)
                except:
                    if getter.__code__.co_names == ('_libsbml', cname):
                        getter = getattr(_libsbml, cname)

            if name in set_methods:
                setter = classdict['set'+name]
                try:
                    argspec = mygetargspec(getter)
                    numargs = len(argspec.args)
                    if numargs > 1 and argspec.args[0] == 'self':
                        cname = classname + '_set' + name
                        try:
                            if setter.func_code.co_names == ('_libsbml', cname):
                                setter = getattr(_libsbml, cname)
                        except:
                            if setter.__code__.co_names == ('_libsbml', cname):
                                setter = getattr(_libsbml, cname)

#property fget does not get intercepted by __getattr__
#but fset does, so we implement property setting via
#the __swig_setmethods__ dict
                        if USE_LIBSBML_PYTHON_API2_WARNINGS:
                            swig_setter[mangled] = p_func_warning_decorator(setter)
                        else:
                            swig_setter[mangled] = setter
                        continue
                except:
                    pass

            if 'unset' + name in classdict:
                deleter = classdict['unset'+name]

                try:
                    argspec = mygetargspec(getter)
                    numargs = len(argspec.args)
                    if numargs == 1 and argspec.args[0] == 'self' and \
                       (argspec.varargs==None or name in allowed_methods):
                        cname = classname + '_unset' + name
                        try:
                            if deleter.func_code.co_names == ('_libsbml', cname):
                                deleter = getattr(_libsbml, cname)
                        except:
                            if deleter.__code__.co_names == ('_libsbml', cname):
                                deleter = getattr(_libsbml, cname)
                except:
                    pass

# wrap mangled deleters
                if USE_LIBSBML_PYTHON_API2_WARNINGS:
                    unset_methods.add(name)

            if getter or setter or deleter:
#fset is technically redundant since the method is dispatched
#via _swig_setattr rather than through the property due to that
#function not delegating to object.__setattr__ which properly
#handles properties
                classdict[mangled] = property(fget=getter, fset=setter, fdel=deleter)


            def __repr__(self):
                desc = self.__class__.__name__
                if hasattr(self, '__len__'):
                    desc += '[%s]' % self.__len__()
                if hasattr(self, 'id') and self.id:
                    desc += ' %s' % self.id
                if hasattr(self, 'name') and self.name:
                    desc += ' "%s"' % self.name
                return '<' + desc + '>'

            if classdict.get('__repr__', None) in (_swig_repr, None):
                classdict['__repr__'] = __repr__

        if USE_LIBSBML_PYTHON_API2_WARNINGS:
# decorate get methods
            for gm in get_methods:
                if 'get'+gm in classdict:
                    classdict['get'+gm] = p_func_warning_decorator(classdict['get'+gm])

# decorate set methods
            for sm in set_methods:
                if 'set'+sm in classdict:
                    classdict['set'+sm] = p_func_warning_decorator(classdict['set'+sm])

# decorate unset methods
            for dm in unset_methods:
                if 'unset'+dm in classdict:
                    classdict['unset'+dm] = p_func_warning_decorator(classdict['unset'+dm])

# decorate unset methods
            if len(add_methods) > 0:
                for am in add_methods:
                    if am in classdict:
                        classdict[am] = p_func_warning_decorator(classdict[am])

        return type.__new__(cls, classname, bases, classdict)


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(SwigPyIterator self) -> PyObject *"""
        return _libsbml.SwigPyIterator_value(self)


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


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


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


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


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


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


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


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


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


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


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


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


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


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


    def __sub__(self, *args):
        """
        __sub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator
        __sub__(SwigPyIterator 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(string self) -> std::basic_string< char >::size_type"""
        return _libsbml.string_length(self)


    def max_size(self):
        """max_size(string self) -> std::basic_string< char >::size_type"""
        return _libsbml.string_max_size(self)


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


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


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


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


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


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


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


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


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


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


    def size(self):
        """size(string self) -> std::basic_string< char >::size_type"""
        return _libsbml.string_size(self)


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


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


    def __init__(self, *args):
        """
        __init__(std::basic_string<(char)> self, char const * __s, std::basic_string< char >::size_type __n) -> string
        __init__(std::basic_string<(char)> self) -> string
        __init__(std::basic_string<(char)> self, string arg2) -> string
        __init__(std::basic_string<(char)> self, std::basic_string< char >::size_type size, std::basic_string< char >::value_type value) -> string
        """
        this = _libsbml.new_string(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def assign(self, *args):
        """
        assign(string self, string __str) -> string
        assign(string self, string __str, std::basic_string< char >::size_type __pos, std::basic_string< char >::size_type __n) -> string
        assign(string self, char const * __s, std::basic_string< char >::size_type __n) -> string
        assign(string self, std::basic_string< char >::size_type n, std::basic_string< char >::value_type x)
        """
        return _libsbml.string_assign(self, *args)


    def resize(self, *args):
        """
        resize(string self, std::basic_string< char >::size_type new_size)
        resize(string self, std::basic_string< char >::size_type new_size, std::basic_string< char >::value_type x)
        """
        return _libsbml.string_resize(self, *args)


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

    def __iter__(self):
        return self.iterator()

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


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


    def __len__(self):
        """__len__(string self) -> std::basic_string< char >::size_type"""
        return _libsbml.string___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(string self, std::basic_string< char >::difference_type i, std::basic_string< char >::difference_type j) -> string"""
        return _libsbml.string___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(string self, std::basic_string< char >::difference_type i, std::basic_string< char >::difference_type j)
        __setslice__(string self, std::basic_string< char >::difference_type i, std::basic_string< char >::difference_type j, string v)
        """
        return _libsbml.string___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(string self, std::basic_string< char >::difference_type i, std::basic_string< char >::difference_type j)"""
        return _libsbml.string___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(string self, std::basic_string< char >::difference_type i)
        __delitem__(string self, PySliceObject * slice)
        """
        return _libsbml.string___delitem__(self, *args)


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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

    __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, __sb):
        """__init__(std::basic_ostream<(char)> self, std::basic_streambuf< char,std::char_traits< char > > * __sb) -> ostream"""
        this = _libsbml.new_ostream(__sb)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            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__(std::basic_ostringstream<(char)> self, std::ios_base::openmode __mode) -> ostringstream
        __init__(std::basic_ostringstream<(char)> self) -> ostringstream
        """
        this = _libsbml.new_ostringstream(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_ostringstream
    __del__ = lambda self: None

    def str(self, *args):
        """
        str(ostringstream self) -> string
        str(ostringstream self, string __s)
        """
        return _libsbml.ostringstream_str(self, *args)

ostringstream_swigregister = _libsbml.ostringstream_swigregister
ostringstream_swigregister(ostringstream)


def endl(arg1):
    """endl(ostream arg1) -> ostream"""
    return _libsbml.endl(arg1)

def flush(arg1):
    """flush(ostream arg1) -> ostream"""
    return _libsbml.flush(arg1)

import sys
import os.path

# @cond doxygenLibsbmlInternal

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)

# @endcond


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

  Reads an SBML document from a file.

  This method is identical to readSBMLFromFile().

  If the file named '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
  SBMLDocument.getError() to get the errors.  The object returned by
  SBMLDocument.getError() 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 '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
  been reported by the underlying operating system.  Callers can check
  for these situations using a program fragment such as the following:

   reader = SBMLReader()
   doc    = reader.readSBML(filename)

   if doc.getNumErrors() > 0:
     if doc.getError(0).getErrorId() == libsbml.XMLFileUnreadable:
# Handle case of unreadable file here.
     elif doc.getError(0).getErrorId() == libsbml.XMLFileOperationError:
# Handle case of other file error here.
     else:
# Handle other error cases here.

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

  To read a gzip/zip file, libSBML needs to be configured and linked with
  the zlib library at compile time.  It also needs to be linked with the
  bzip2 library to read files in 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 not
  linked with the corresponding required library.

  Parameter 'filename is the name or full pathname of the file to be
  read.

  Returns a pointer to the SBMLDocument created from the SBML content.

  See also SBMLError.

  Note:

  LibSBML versions 2.x and later versions 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 versions after 2.x
  stop parsing SBML inputs sooner than libSBML version 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 and later, 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.
  """
  reader = SBMLReader()
  return reader.readSBML(args[0])

class ListWrapperSBMLNamespaces(_object):
    """Proxy of C++ ListWrapper<(SBMLNamespaces)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListWrapperSBMLNamespaces, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ListWrapperSBMLNamespaces, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(ListWrapper<(SBMLNamespaces)> self) -> ListWrapperSBMLNamespaces"""
        this = _libsbml.new_ListWrapperSBMLNamespaces()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_ListWrapperSBMLNamespaces
    __del__ = lambda self: None

    def add(self, item):
        """add(ListWrapperSBMLNamespaces self, SBMLNamespaces item)"""
        return _libsbml.ListWrapperSBMLNamespaces_add(self, item)


    def get(self, n):
        """get(ListWrapperSBMLNamespaces self, unsigned int n) -> SBMLNamespaces"""
        return _libsbml.ListWrapperSBMLNamespaces_get(self, n)


    def prepend(self, item):
        """prepend(ListWrapperSBMLNamespaces self, SBMLNamespaces item)"""
        return _libsbml.ListWrapperSBMLNamespaces_prepend(self, item)


    def remove(self, n):
        """remove(ListWrapperSBMLNamespaces self, unsigned int n) -> SBMLNamespaces"""
        return _libsbml.ListWrapperSBMLNamespaces_remove(self, n)


    def getSize(self):
        """getSize(ListWrapperSBMLNamespaces self) -> unsigned int"""
        return _libsbml.ListWrapperSBMLNamespaces_getSize(self)


    def __len__(self):
        """__len__(ListWrapperSBMLNamespaces self) -> int"""
        return _libsbml.ListWrapperSBMLNamespaces___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.getSize()
        return [self[i] for i in range(
          self._fixNegativeIndex(start), self._fixNegativeIndex(stop)
        )]

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


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


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


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


    def __str__(self):
      return repr(self)

ListWrapperSBMLNamespaces_swigregister = _libsbml.ListWrapperSBMLNamespaces_swigregister
ListWrapperSBMLNamespaces_swigregister(ListWrapperSBMLNamespaces)
cout = cvar.cout
cerr = cvar.cerr
clog = cvar.clog

class ListWrapperCVTerm(_object):
    """Proxy of C++ ListWrapper<(CVTerm)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListWrapperCVTerm, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ListWrapperCVTerm, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(ListWrapper<(CVTerm)> self) -> ListWrapperCVTerm"""
        this = _libsbml.new_ListWrapperCVTerm()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_ListWrapperCVTerm
    __del__ = lambda self: None

    def add(self, item):
        """add(ListWrapperCVTerm self, CVTerm item)"""
        return _libsbml.ListWrapperCVTerm_add(self, item)


    def get(self, n):
        """get(ListWrapperCVTerm self, unsigned int n) -> CVTerm"""
        return _libsbml.ListWrapperCVTerm_get(self, n)


    def prepend(self, item):
        """prepend(ListWrapperCVTerm self, CVTerm item)"""
        return _libsbml.ListWrapperCVTerm_prepend(self, item)


    def remove(self, n):
        """remove(ListWrapperCVTerm self, unsigned int n) -> CVTerm"""
        return _libsbml.ListWrapperCVTerm_remove(self, n)


    def getSize(self):
        """getSize(ListWrapperCVTerm self) -> unsigned int"""
        return _libsbml.ListWrapperCVTerm_getSize(self)


    def __len__(self):
        """__len__(ListWrapperCVTerm self) -> int"""
        return _libsbml.ListWrapperCVTerm___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.getSize()
        return [self[i] for i in range(
          self._fixNegativeIndex(start), self._fixNegativeIndex(stop)
        )]

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


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


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


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


    def __str__(self):
      return repr(self)

ListWrapperCVTerm_swigregister = _libsbml.ListWrapperCVTerm_swigregister
ListWrapperCVTerm_swigregister(ListWrapperCVTerm)

class ListWrapperDate(_object):
    """Proxy of C++ ListWrapper<(Date)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListWrapperDate, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ListWrapperDate, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(ListWrapper<(Date)> self) -> ListWrapperDate"""
        this = _libsbml.new_ListWrapperDate()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_ListWrapperDate
    __del__ = lambda self: None

    def add(self, item):
        """add(ListWrapperDate self, Date item)"""
        return _libsbml.ListWrapperDate_add(self, item)


    def get(self, n):
        """get(ListWrapperDate self, unsigned int n) -> Date"""
        return _libsbml.ListWrapperDate_get(self, n)


    def prepend(self, item):
        """prepend(ListWrapperDate self, Date item)"""
        return _libsbml.ListWrapperDate_prepend(self, item)


    def remove(self, n):
        """remove(ListWrapperDate self, unsigned int n) -> Date"""
        return _libsbml.ListWrapperDate_remove(self, n)


    def getSize(self):
        """getSize(ListWrapperDate self) -> unsigned int"""
        return _libsbml.ListWrapperDate_getSize(self)


    def __len__(self):
        """__len__(ListWrapperDate self) -> int"""
        return _libsbml.ListWrapperDate___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.getSize()
        return [self[i] for i in range(
          self._fixNegativeIndex(start), self._fixNegativeIndex(stop)
        )]

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


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


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


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


    def __str__(self):
      return repr(self)

ListWrapperDate_swigregister = _libsbml.ListWrapperDate_swigregister
ListWrapperDate_swigregister(ListWrapperDate)

class ListWrapperModelCreator(_object):
    """Proxy of C++ ListWrapper<(ModelCreator)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListWrapperModelCreator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ListWrapperModelCreator, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(ListWrapper<(ModelCreator)> self) -> ListWrapperModelCreator"""
        this = _libsbml.new_ListWrapperModelCreator()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_ListWrapperModelCreator
    __del__ = lambda self: None

    def add(self, item):
        """add(ListWrapperModelCreator self, ModelCreator item)"""
        return _libsbml.ListWrapperModelCreator_add(self, item)


    def get(self, n):
        """get(ListWrapperModelCreator self, unsigned int n) -> ModelCreator"""
        return _libsbml.ListWrapperModelCreator_get(self, n)


    def prepend(self, item):
        """prepend(ListWrapperModelCreator self, ModelCreator item)"""
        return _libsbml.ListWrapperModelCreator_prepend(self, item)


    def remove(self, n):
        """remove(ListWrapperModelCreator self, unsigned int n) -> ModelCreator"""
        return _libsbml.ListWrapperModelCreator_remove(self, n)


    def getSize(self):
        """getSize(ListWrapperModelCreator self) -> unsigned int"""
        return _libsbml.ListWrapperModelCreator_getSize(self)


    def __len__(self):
        """__len__(ListWrapperModelCreator self) -> int"""
        return _libsbml.ListWrapperModelCreator___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.getSize()
        return [self[i] for i in range(
          self._fixNegativeIndex(start), self._fixNegativeIndex(stop)
        )]

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


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


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


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


    def __str__(self):
      return repr(self)

ListWrapperModelCreator_swigregister = _libsbml.ListWrapperModelCreator_swigregister
ListWrapperModelCreator_swigregister(ListWrapperModelCreator)

class ListWrapperSBase(_object):
    """Proxy of C++ ListWrapper<(SBase)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListWrapperSBase, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ListWrapperSBase, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(ListWrapper<(SBase)> self) -> ListWrapperSBase"""
        this = _libsbml.new_ListWrapperSBase()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_ListWrapperSBase
    __del__ = lambda self: None

    def add(self, item):
        """add(ListWrapperSBase self, SBase item)"""
        return _libsbml.ListWrapperSBase_add(self, item)


    def get(self, n):
        """get(ListWrapperSBase self, unsigned int n) -> SBase"""
        return _libsbml.ListWrapperSBase_get(self, n)


    def prepend(self, item):
        """prepend(ListWrapperSBase self, SBase item)"""
        return _libsbml.ListWrapperSBase_prepend(self, item)


    def remove(self, n):
        """remove(ListWrapperSBase self, unsigned int n) -> SBase"""
        return _libsbml.ListWrapperSBase_remove(self, n)


    def getSize(self):
        """getSize(ListWrapperSBase self) -> unsigned int"""
        return _libsbml.ListWrapperSBase_getSize(self)


    def __len__(self):
        """__len__(ListWrapperSBase self) -> int"""
        return _libsbml.ListWrapperSBase___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.getSize()
        return [self[i] for i in range(
          self._fixNegativeIndex(start), self._fixNegativeIndex(stop)
        )]

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


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


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


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


    def __str__(self):
      return repr(self)

ListWrapperSBase_swigregister = _libsbml.ListWrapperSBase_swigregister
ListWrapperSBase_swigregister(ListWrapperSBase)

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 version number of this copy of libSBML as an integer.

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

    """
    return _libsbml.getLibSBMLVersion()

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


    Returns the version number of this copy of libSBML as a string.

    Returns the libSBML version as a string; version 1.2.3 becomes
    '1.2.3'.

    See also getLibSBMLVersionString().

    """
    return _libsbml.getLibSBMLDottedVersion()

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


    Returns the version number of this copy of libSBML as a string without
    periods.

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

    See also getLibSBMLDottedVersion().

    """
    return _libsbml.getLibSBMLVersionString()

def isLibSBMLCompiledWith(option):
    """
    isLibSBMLCompiledWith(char const * option) -> int


    Returns an indication whether libSBML has been compiled with against a
    specific library.

    Parameter 'option' is the library to test against, this can be one of
    'expat', 'libxml', 'xerces-c', 'bzip2', 'zip'

    Returns 0 in case the libSBML has not been compiled against  that
    library and non-zero otherwise (for libraries  that define an integer
    version number that number will  be returned).

    See also getLibSBMLDependencyVersionOf().

    """
    return _libsbml.isLibSBMLCompiledWith(option)

def getLibSBMLDependencyVersionOf(option):
    """
    getLibSBMLDependencyVersionOf(char const * option) -> char const *


    Returns the version string for the dependency library used.

    Parameter 'option' is the library for which the version should be
    retrieved, this can be one of 'expat', 'libxml', 'xerces-c', 'bzip2',
    'zip'

    Returns None in case libSBML has not been compiled against  that
    library and a version string otherwise.

    See also isLibSBMLCompiledWith().

    """
    return _libsbml.getLibSBMLDependencyVersionOf(option)
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
LIBSBML_NAMESPACES_MISMATCH = _libsbml.LIBSBML_NAMESPACES_MISMATCH
LIBSBML_DUPLICATE_ANNOTATION_NS = _libsbml.LIBSBML_DUPLICATE_ANNOTATION_NS
LIBSBML_ANNOTATION_NAME_NOT_FOUND = _libsbml.LIBSBML_ANNOTATION_NAME_NOT_FOUND
LIBSBML_ANNOTATION_NS_NOT_FOUND = _libsbml.LIBSBML_ANNOTATION_NS_NOT_FOUND
LIBSBML_MISSING_METAID = _libsbml.LIBSBML_MISSING_METAID
LIBSBML_DEPRECATED_ATTRIBUTE = _libsbml.LIBSBML_DEPRECATED_ATTRIBUTE
LIBSBML_USE_ID_ATTRIBUTE_FUNCTION = _libsbml.LIBSBML_USE_ID_ATTRIBUTE_FUNCTION
LIBSBML_PKG_VERSION_MISMATCH = _libsbml.LIBSBML_PKG_VERSION_MISMATCH
LIBSBML_PKG_UNKNOWN = _libsbml.LIBSBML_PKG_UNKNOWN
LIBSBML_PKG_UNKNOWN_VERSION = _libsbml.LIBSBML_PKG_UNKNOWN_VERSION
LIBSBML_PKG_DISABLED = _libsbml.LIBSBML_PKG_DISABLED
LIBSBML_PKG_CONFLICTED_VERSION = _libsbml.LIBSBML_PKG_CONFLICTED_VERSION
LIBSBML_PKG_CONFLICT = _libsbml.LIBSBML_PKG_CONFLICT
LIBSBML_CONV_INVALID_TARGET_NAMESPACE = _libsbml.LIBSBML_CONV_INVALID_TARGET_NAMESPACE
LIBSBML_CONV_PKG_CONVERSION_NOT_AVAILABLE = _libsbml.LIBSBML_CONV_PKG_CONVERSION_NOT_AVAILABLE
LIBSBML_CONV_INVALID_SRC_DOCUMENT = _libsbml.LIBSBML_CONV_INVALID_SRC_DOCUMENT
LIBSBML_CONV_CONVERSION_NOT_AVAILABLE = _libsbml.LIBSBML_CONV_CONVERSION_NOT_AVAILABLE
LIBSBML_CONV_PKG_CONSIDERED_UNKNOWN = _libsbml.LIBSBML_CONV_PKG_CONSIDERED_UNKNOWN

def OperationReturnValue_toString(returnValue):
    """
    OperationReturnValue_toString(int returnValue) -> char const *


    This method takes an SBML operation return value and returns a string
    representing the code.

    Parameter 'returnValue' is the operation return value to convert to a
    string.

    Returns a human readable name for the given operation return value .

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

    """
    return _libsbml.OperationReturnValue_toString(returnValue)
class IdList(_object):
    """

    Internal implementation method.

    """

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IdList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IdList, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(IdList self) -> IdList
        __init__(IdList self, string commaSeparated) -> IdList


        Internal implementation method.

        """
        this = _libsbml.new_IdList(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def append(self, id):
        """
        append(IdList self, string id)


        Internal implementation method.

        """
        return _libsbml.IdList_append(self, id)


    def contains(self, id):
        """
        contains(IdList self, string id) -> bool


        Internal implementation method.

        """
        return _libsbml.IdList_contains(self, id)


    def empty(self):
        """
        empty(IdList self) -> bool


        Internal implementation method.

        """
        return _libsbml.IdList_empty(self)


    def removeIdsBefore(self, id):
        """
        removeIdsBefore(IdList self, string id)


        Internal implementation method.

        """
        return _libsbml.IdList_removeIdsBefore(self, id)


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


        Internal implementation method.

        """
        return _libsbml.IdList_size(self)


    def clear(self):
        """clear(IdList self)"""
        return _libsbml.IdList_clear(self)


    def at(self, n):
        """at(IdList self, int n) -> string"""
        return _libsbml.IdList_at(self, n)

    __swig_destroy__ = _libsbml.delete_IdList
    __del__ = lambda self: None
IdList_swigregister = _libsbml.IdList_swigregister
IdList_swigregister(IdList)

class IdentifierTransformer(_object):
    """

    Internal implementation method.

    """

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IdentifierTransformer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IdentifierTransformer, name)
    __repr__ = _swig_repr

    def __init__(self):
        """
        __init__(IdentifierTransformer self) -> IdentifierTransformer


        Internal implementation method.

        """
        if self.__class__ == IdentifierTransformer:
            _self = None
        else:
            _self = self
        this = _libsbml.new_IdentifierTransformer(_self, )
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_IdentifierTransformer
    __del__ = lambda self: None

    def transform(self, element):
        """transform(IdentifierTransformer self, SBase element) -> int"""
        return _libsbml.IdentifierTransformer_transform(self, element)

    def __disown__(self):
        self.this.disown()
        _libsbml.disown_IdentifierTransformer(self)
        return weakref_proxy(self)
IdentifierTransformer_swigregister = _libsbml.IdentifierTransformer_swigregister
IdentifierTransformer_swigregister(IdentifierTransformer)

class ElementFilter(_object):
    """

    Base class for filter functions.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  It is a class used in the
    implementation of extra functionality provided by libSBML.

    Some libSBML objects provide the ability to return lists of
    components. To provide callers with greater control over exactly what
    is returned, these methods take optional arguments in the form of
    filters. The ElementFilter class is the parent class for these
    filters.

    """

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ElementFilter, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ElementFilter, name)
    __repr__ = _swig_repr

    def __init__(self):
        """
        __init__(ElementFilter self) -> ElementFilter


        Creates a new ElementFilter object.

        """
        if self.__class__ == ElementFilter:
            _self = None
        else:
            _self = self
        this = _libsbml.new_ElementFilter(_self, )
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_ElementFilter
    __del__ = lambda self: None

    def filter(self, element):
        """
        filter(ElementFilter self, SBase element) -> bool


        Predicate to test elements.

        This is the central predicate of the ElementFilter class.  In
        subclasses of ElementFilter, callers should implement this method such
        that it returns 'True' for 'element' arguments that are 'desirable'
        and 'False' for those that are 'undesirable' in whatever filtering
        context the ElementFilter subclass is designed to be used.

        Parameter 'element' is the element to be tested.

        Returns 'True' if the 'element' is desirable or should be kept,
        'False' otherwise.

        """
        return _libsbml.ElementFilter_filter(self, element)

    def __disown__(self):
        self.this.disown()
        _libsbml.disown_ElementFilter(self)
        return weakref_proxy(self)
ElementFilter_swigregister = _libsbml.ElementFilter_swigregister
ElementFilter_swigregister(ElementFilter)

class SBMLReader(_object):
    """

    File and text-string SBML reader.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    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.  Consequently, immediately
    after calling a method on SBMLReader, callers should always check for
    errors and warnings using the methods for this purpose provided by
    SBMLDocument.

    For convenience as well as easy access from other languages besides
    C++, this file also defines two global functions,
    @sbmlglobalfunction{readSBML, String} and
    @sbmlglobalfunction{readSBMLFromString, String}.  They are equivalent
    to creating an SBMLReader object and then calling the
    SBMLReader.readSBML() and SBMLReader.readSBMLFromString() methods,
    respectively.

    Support for reading compressed files
    ======================================================================

    LibSBML provides support for reading (as well as writing) compressed
    SBML files.  The process is transparent to the calling application---
    the application does not need to do anything deliberate to invoke the
    functionality.  If a given SBML filename ends with an extension for
    the gzip, zip or bzip2 compression formats (respectively, '.gz,'
    '.zip,' or '.bz2),' then the methods SBMLReader.readSBML() and
    SBMLWriter.writeSBML() will automatically decompress and compress the
    file while reading and writing it.  If the filename has no such
    extension, it will be read and written uncompressed as normal.

    The compression feature requires that the zlib (for gzip and zip
    formats) and/or bzip2 (for bzip2 format) be available on the system
    running libSBML, and that libSBML was configured with their support
    compiled-in.  Please see the libSBML installation instructions for
    more information about this.  The methods hasZlib() and hasBzip2() can
    be used by an application to query at run-time whether support for the
    compression libraries is available in the present copy of libSBML.

    Support for compression is not mandated by the SBML standard, but
    applications may find it helpful, particularly when large SBML models
    are being communicated across data links of limited bandwidth.

    """

    __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__(SBMLReader self) -> SBMLReader


        Creates a new SBMLReader object and returns it.

        The libSBML SBMLReader object offers methods for reading SBML in XML
        form from files and text strings.

        """
        this = _libsbml.new_SBMLReader()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_SBMLReader
    __del__ = lambda self: None

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

      Reads an SBML document from a file.

      This method is identical to readSBMLFromFile().

      If the file named '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
      SBMLDocument.getError() to get the errors.  The object returned by
      SBMLDocument.getError() 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 '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
      been reported by the underlying operating system.  Callers can check
      for these situations using a program fragment such as the following:

       reader = SBMLReader()
       doc    = reader.readSBML(filename)

       if doc.getNumErrors() > 0:
         if doc.getError(0).getErrorId() == libsbml.XMLFileUnreadable:
    # Handle case of unreadable file here.
         elif doc.getError(0).getErrorId() == libsbml.XMLFileOperationError:
    # Handle case of other file error here.
         else:
    # Handle other error cases here.

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

      To read a gzip/zip file, libSBML needs to be configured and linked with
      the zlib library at compile time.  It also needs to be linked with the
      bzip2 library to read files in 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 not
      linked with the corresponding required library.

      Parameter 'filename is the name or full pathname of the file to be
      read.

      Returns a pointer to the SBMLDocument created from the SBML content.

      See also SBMLError.

      Note:

      LibSBML versions 2.x and later versions 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 versions after 2.x
      stop parsing SBML inputs sooner than libSBML version 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 and later, 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.
      """
      args_copy    = list(args)
      args_copy[1] = conditional_abspath(args[1])
      return _libsbml.SBMLReader_readSBML(*args_copy)



    def readSBMLFromFile(*args):
      """
      Reads an SBML document from the given file.

      If the file named '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
      SBMLDocument.getError() to get the errors.  The object returned by
      SBMLDocument.getError() 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 '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
      been reported by the underlying operating system.  Callers can check
      for these situations using a program fragment such as the following:

        reader = SBMLReader()
        if reader == None:
    # Handle the truly exceptional case of no object created here.

        doc = reader.readSBMLFromFile(filename)
        if doc.getNumErrors() > 0:
          if doc.getError(0).getErrorId() == XMLFileUnreadable:
    # Handle case of unreadable file here.
          elif doc.getError(0).getErrorId() == XMLFileOperationError:
    # Handle case of other file error here.
          else:
    # Handle other error cases here.

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

      To read a gzip/zip file, libSBML needs to be configured and linked
      with the zlib library at compile time.  It also needs to be linked
      with the bzip2 library to read files in 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
      not linked with the corresponding required library.

      Parameter 'filename' is the name or full pathname of the file to be
      read.

      Returns a pointer to the SBMLDocument structure created from the SBML
      content in 'filename'.
      """
      args_copy    = list(args)
      args_copy[1] = conditional_abspath(args[1])
      return _libsbml.SBMLReader_readSBML(*args_copy)



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


        Reads an SBML document from a text 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 'xml' does not begin with the XML declaration

          <?xml version='1.0' encoding='UTF-8'?>

        then this method will automatically prepend the declaration to 'xml'.

        This method will log a fatal error if the content given in the
        parameter 'xml' is not in SBML format.  See the method documentation
        for SBMLReader.readSBML()

        for an example of code for testing the returned error code.

        Parameter 'xml' is a string containing a full SBML model.

        Returns a pointer to the SBMLDocument created from the SBML content,
        or a null pointer if 'xml' is 'None.'

        Note: When using this method to read an SBMLDocument that uses the
        SBML Level 3 Hierarchical Model Composition package (comp) the
        document location cannot be set automatically. Thus, if the model
        contains references to ExternalModelDefinition objects, it will be
        necessary to manually set the document URI location
        (SBMLDocument.setLocationURI()

        ) in order to facilitate resolving these models.

        See also SBMLReader.readSBML().

        """
        return _libsbml.SBMLReader_readSBMLFromString(self, xml)


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


        Static method; returns 'True' if this copy of libSBML supports gzip
        and zip format compression.

        Returns 'True' if libSBML has been linked with the zlib library,
        'False' otherwise.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        See also SBMLReader.hasBzip2().

        """
        return _libsbml.SBMLReader_hasZlib()

    hasZlib = staticmethod(hasZlib)

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


        Static method; returns 'True' if this copy of libSBML supports bzip2
        format compression.

        Returns 'True' if libSBML is linked with the bzip2 libraries, 'False'
        otherwise.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        See also SBMLReader.hasZlib().

        """
        return _libsbml.SBMLReader_hasBzip2()

    hasBzip2 = staticmethod(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)

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


    Static method; returns 'True' if this copy of libSBML supports gzip
    and zip format compression.

    Returns 'True' if libSBML has been linked with the zlib library,
    'False' otherwise.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    See also SBMLReader.hasBzip2().

    """
    return _libsbml.SBMLReader_hasZlib()

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


    Static method; returns 'True' if this copy of libSBML supports bzip2
    format compression.

    Returns 'True' if libSBML is linked with the bzip2 libraries, 'False'
    otherwise.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    See also SBMLReader.hasZlib().

    """
    return _libsbml.SBMLReader_hasBzip2()


def readSBMLFromFile(filename):
    """
    readSBMLFromFile(char const * filename) -> SBMLDocument


    Reads an SBML document from the given file.

    If the file named '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(),
    SBMLDocument.getNumErrors() and SBMLDocument.getError()

    to get the errors.  The object returned by SBMLDocument.getError()

    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 '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
    privileges to read it) or some sort of file operation error may have
    been reported by the underlying operating system.  Callers can check
    for these situations using a program fragment such as the following:

      reader = SBMLReader()
      if reader == None:
        # Handle the truly exceptional case of no object created here.

      doc = reader.readSBMLFromFile(filename)
      if doc.getNumErrors() > 0:
        if doc.getError(0).getErrorId() == XMLFileUnreadable:
          # Handle case of unreadable file here.
        elif doc.getError(0).getErrorId() == XMLFileOperationError:
          # Handle case of other file error here.
        else:
          # Handle other error cases here.

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

    To read a gzip/zip file, libSBML needs to be configured and linked
    with the zlib library at compile time.  It also needs to be linked
    with the bzip2 library to read files in 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
    not linked with the corresponding required library.

    Parameter 'filename' is the name or full pathname of the file to be
    read.

    Returns a pointer to the SBMLDocument structure created from the SBML
    content in 'filename'.

    """
    return _libsbml.readSBMLFromFile(filename)

def readSBMLFromString(xml):
    """
    readSBMLFromString(char const * xml) -> SBMLDocument


    Reads an SBML document from a text 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 'xml' does not begin with the XML declaration

      <?xml version='1.0' encoding='UTF-8'?>

    then this method will automatically prepend the declaration to 'xml'.

    This method will log a fatal error if the content given in the
    parameter 'xml' is not in SBML format.  See the method documentation
    for SBMLReader.readSBML()

    for an example of code for testing the returned error code.

    Parameter 'xml' is a string containing a full SBML model.

    Returns a pointer to the SBMLDocument structure created from the SBML
    content in 'xml'.

    Note: When using this method to read an SBMLDocument that uses the
    SBML Level 3 Hierarchical Model Composition package (comp) the
    document location cannot be set automatically. Thus, if the model
    contains references to ExternalModelDefinition objects, it will be
    necessary to manually set the document URI location
    (SBMLDocument.setLocationURI()

    ) in order to facilitate resolving these models.

    """
    return _libsbml.readSBMLFromString(xml)
class SBMLWriter(_object):
    """

    File and text-string SBML writer.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

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

    Support for writing compressed files
    ======================================================================

    LibSBML provides support for writing (as well as reading) compressed
    SBML files.  The process is transparent to the calling application---
    the application does not need to do anything deliberate to invoke the
    functionality.  If a given SBML filename ends with an extension for
    the gzip, zip or bzip2 compression formats (respectively, ".gz",
    ".zip", or ".bz2"), then the methods SBMLWriter.writeSBML() and
    SBMLReader.readSBML() will automatically compress and decompress the
    file while writing and reading it.  If the filename has no such
    extension, it will be written and read uncompressed as normal.

    The compression feature requires that the zlib (for gzip and zip
    formats) and/or bzip2 (for bzip2 format) be available on the system
    running libSBML, and that libSBML was configured with their support
    compiled-in.  Please see the libSBML installation instructions for
    more information about this.  The methods SBMLWriter.hasZlib() and
    SBMLWriter.hasBzip2() can be used by an application to query at run-
    time whether support for the compression libraries is available in the
    present copy of libSBML.

    Support for compression is not mandated by the SBML standard, but
    applications may find it helpful, particularly when large SBML models
    are being communicated across data links of limited bandwidth.

    """

    __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__(SBMLWriter self) -> SBMLWriter


        Creates a new SBMLWriter.

        The libSBML SBMLWriter objects offer methods for writing SBML in XML
        form to files and text strings.

        """
        this = _libsbml.new_SBMLWriter()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_SBMLWriter
    __del__ = lambda self: None

    def setProgramName(self, name):
        """
        setProgramName(SBMLWriter 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 (see
        SBMLWriter.setProgramVersion()), the following XML comment, intended
        for human consumption, will be written at the beginning of the XML
        document:

           <!-- Created by <program name> version <program version>
           on yyyy-MM-dd HH:mm with libSBML version <libsbml version>. -->

        If the program name and version are not set at some point before
        calling the writeSBML() methods, no such comment is written out.

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

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        See also setProgramVersion().

        """
        return _libsbml.SBMLWriter_setProgramName(self, name)


    def setProgramVersion(self, version):
        """
        setProgramVersion(SBMLWriter 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 (see
        SBMLWriter.setProgramName()), the following XML comment, intended for
        human consumption, will be written at the beginning of the document:

           <!-- Created by <program name> version <program version>
           on yyyy-MM-dd HH:mm with libSBML version <libsbml version>. -->

        If the program version and name are not set at some point before
        calling the writeSBML() methods, no such comment is written out.

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

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        See also setProgramName().

        """
        return _libsbml.SBMLWriter_setProgramVersion(self, version)


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            writeSBML(SBMLDocument d, string filename)

        Writes the given SBML document to filename.

        If the given filename ends with the suffix ".gz" (for example,
        "myfile.xml.gz"), libSBML assumes the caller wants the file to be
        written compressed in gzip format. Similarly, if the given filename
        ends with ".zip" or ".bz2", libSBML assumes the caller wants the
        file to be compressed in zip or bzip2 format (respectively). Files
        whose names lack these suffixes will be written uncompressed. Special
        considerations for the zip format: If the given filename ends with
        ".zip", the file placed in the zip archive will have the suffix
        ".xml" or ".sbml".  For example, the file in the zip archive will
        be named "test.xml" if the given filename is "test.xml.zip" or
        "test.zip". Similarly, the filename in the archive will be
        "test.sbml" if the given filename is "test.sbml.zip".

        Parameter 'd' is the SBML document to be written.

        Parameter 'filename' is the name or full pathname of the file where
        the SBML is to be written.

        Returns 'True' on success and 'False' if the filename could not be
        opened for writing.

        Note: To write a gzip/zip file, libSBML needs to be configured and
        linked with the zlib library at compile time.  It also needs to be
        linked with the bzip2 library to write files in bzip2 format.  (Both
        of these are the default configurations for libSBML.)  Errors about
        unreadable files will be logged and this method will return false if a
        compressed filename is given and libSBML was not linked with the
        corresponding required library.

        See also setProgramVersion(), setProgramName().

        ______________________________________________________________________
        Method variant with the following signature:

            writeSBML(SBMLDocument d, std::ostream& stream)

        Writes the given SBML document to the output stream.

        Parameter 'd' is the SBML document to be written.

        Parameter 'stream' is the stream object where the SBML is to be
        written.

        Returns 'True' on success and 'False' if one of the underlying parser
        components fail (rare).

        See also setProgramVersion(), setProgramName().

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


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


        Internal implementation method.

        """
        return _libsbml.SBMLWriter_writeToString(self, d)


    def writeSBMLToFile(self, d, filename):
        """
        writeSBMLToFile(SBMLWriter self, SBMLDocument d, string filename) -> bool


        Writes the given SBML document to filename.

        If the given filename ends with the suffix ".gz" (for example,
        "myfile.xml.gz"), libSBML assumes the caller wants the file to be
        written compressed in gzip format. Similarly, if the given filename
        ends with ".zip" or ".bz2", libSBML assumes the caller wants the
        file to be compressed in zip or bzip2 format (respectively). Files
        whose names lack these suffixes will be written uncompressed. Special
        considerations for the zip format: If the given filename ends with
        ".zip", the file placed in the zip archive will have the suffix
        ".xml" or ".sbml".  For example, the file in the zip archive will
        be named "test.xml" if the given filename is "test.xml.zip" or
        "test.zip". Similarly, the filename in the archive will be
        "test.sbml" if the given filename is "test.sbml.zip".

        Parameter 'd' is the SBML document to be written.

        Parameter 'filename' is the name or full pathname of the file where
        the SBML is to be written.

        Returns 'True' on success and 'False' if the filename could not be
        opened for writing.

        Note: To write a gzip/zip file, libSBML needs to be configured and
        linked with the zlib library at compile time.  It also needs to be
        linked with the bzip2 library to write files in bzip2 format.  (Both
        of these are the default configurations for libSBML.)  Errors about
        unreadable files will be logged and this method will return false if a
        compressed filename is given and libSBML was not linked with the
        corresponding required library.

        See also setProgramVersion(), setProgramName().

        """
        return _libsbml.SBMLWriter_writeSBMLToFile(self, d, filename)


    def writeSBMLToString(self, d):
        """
        writeSBMLToString(SBMLWriter 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 'free())'
        when no longer needed.

        Parameter 'd' is the SBML document to be written.

        Returns the string on success and '0' if one of the underlying parser
        components fail.

        See also setProgramVersion(), setProgramName().

        """
        return _libsbml.SBMLWriter_writeSBMLToString(self, d)


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


        Predicate returning 'True' if this copy of libSBML has been linked
        with the zlib library.

        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 using.

        Returns 'True' if libSBML is linked with zlib, 'False' otherwise.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        See also SBMLWriter.hasBzip2() .

        """
        return _libsbml.SBMLWriter_hasZlib()

    hasZlib = staticmethod(hasZlib)

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


        Predicate returning 'True' if this copy of libSBML has been linked
        with the bzip2 library.

        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 using.

        Returns 'True' if libSBML is linked with bzip2, 'False' otherwise.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        See also SBMLWriter.hasZlib() .

        """
        return _libsbml.SBMLWriter_hasBzip2()

    hasBzip2 = staticmethod(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 'True' if this copy of libSBML has been linked
    with the zlib library.

    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 using.

    Returns 'True' if libSBML is linked with zlib, 'False' otherwise.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    See also SBMLWriter.hasBzip2() .

    """
    return _libsbml.SBMLWriter_hasZlib()

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


    Predicate returning 'True' if this copy of libSBML has been linked
    with the bzip2 library.

    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 using.

    Returns 'True' if libSBML is linked with bzip2, 'False' otherwise.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    See also SBMLWriter.hasZlib() .

    """
    return _libsbml.SBMLWriter_hasBzip2()


def writeSBML(d, filename):
    """
    writeSBML(SBMLDocument d, char const * filename) -> int


    Writes the given SBML document 'd' to the file named by 'filename'.
    This convenience function is functionally equivalent to:

    SBMLWriter_writeSBML(SBMLWriter_create(), d, filename);

    If the given filename ends with the suffix ".gz" (for example,
    "myfile.xml.gz"), libSBML assumes the caller wants the file to be
    written compressed in gzip format. Similarly, if the given filename
    ends with ".zip" or ".bz2", libSBML assumes the caller wants the
    file to be compressed in zip or bzip2 format (respectively). Files
    whose names lack these suffixes will be written uncompressed. Special
    considerations for the zip format: If the given filename ends with
    ".zip", the file placed in the zip archive will have the suffix
    ".xml" or ".sbml".  For example, the file in the zip archive will
    be named "test.xml" if the given filename is "test.xml.zip" or
    "test.zip". Similarly, the filename in the archive will be
    "test.sbml" if the given filename is "test.sbml.zip".

    Parameter 'd' is the SBMLDocument object to be written out in XML
    format.

    Parameter 'filename' is a string giving the path to a file where the
    XML content is to be written.

    Returns '1' (true) on success and '0' (false) if 'filename' could not
    be written.  Some possible reasons for failure include (a) being
    unable to open the file, and (b) using a filename that indicates a
    compressed SBML file (i.e., a filename ending in ".zip" or similar)
    when the compression functionality has not been enabled in the
    underlying copy of libSBML.

    See also SBMLWriter.hasZlib(), SBMLWriter.hasBzip2().

    """
    return _libsbml.writeSBML(d, filename)

def writeSBMLToString(d):
    """
    writeSBMLToString(SBMLDocument d) -> char *


    Writes the given SBML document 'd' 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);

    but does not require the caller to create an SBMLWriter object first.

    Parameter 'd' is an SBMLDocument object to be written out in XML
    format.

    Returns the string on success and 'None' if one of the underlying
    parser components fail.

    """
    return _libsbml.writeSBMLToString(d)

def writeSBMLToFile(d, filename):
    """
    writeSBMLToFile(SBMLDocument d, char const * filename) -> int


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

    SBMLWriter_writeSBMLToFile(SBMLWriter_create(), d, filename);

    but that does not require the caller to create an SBMLWriter object
    first.

    If the given filename ends with the suffix ".gz" (for example,
    "myfile.xml.gz"), libSBML assumes the caller wants the file to be
    written compressed in gzip format. Similarly, if the given filename
    ends with ".zip" or ".bz2", libSBML assumes the caller wants the
    file to be compressed in zip or bzip2 format (respectively). Files
    whose names lack these suffixes will be written uncompressed. Special
    considerations for the zip format: If the given filename ends with
    ".zip", the file placed in the zip archive will have the suffix
    ".xml" or ".sbml".  For example, the file in the zip archive will
    be named "test.xml" if the given filename is "test.xml.zip" or
    "test.zip". Similarly, the filename in the archive will be
    "test.sbml" if the given filename is "test.sbml.zip".

    Parameter 'd' is an SBMLDocument object to be written out in XML
    format.

    Parameter 'filename' is a string giving the path to a file where the
    XML content is to be written.

    Returns '1' (true) on success and '0' (false) if 'filename' could not
    be written.  Some possible reasons for failure include (a) being
    unable to open the file, and (b) using a filename that indicates a
    compressed SBML file (i.e., a filename ending in ".zip" or similar)
    when the compression functionality has not been enabled in the
    underlying copy of libSBML.

    See also SBMLWriter.hasZlib(), SBMLWriter.hasBzip2().

    """
    return _libsbml.writeSBMLToFile(d, filename)
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_LOCAL_PARAMETER = _libsbml.SBML_LOCAL_PARAMETER
SBML_PRIORITY = _libsbml.SBML_PRIORITY
SBML_GENERIC_SBASE = _libsbml.SBML_GENERIC_SBASE

def SBMLTypeCode_toString(tc, pkgName):
    """
    SBMLTypeCode_toString(int tc, char const * pkgName) -> char const *


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

    LibSBML attaches an identifying code to every kind of SBML object.
    These are known as SBML type codes.  In the Python language interface
    for libSBML, the type codes are defined as static integer constants in
    the interface class 'libsbml'.  The names of the type codes all begin
    with the characters 'SBML_.'

    Returns a human readable name for the given SBML type code.

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

    """
    return _libsbml.SBMLTypeCode_toString(tc, pkgName)
class SBase(_object):
    """

    SBML's SBase class, base class of most 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; please consult the SBML
    specification document corresponding to the SBML Level and Version of
    your model for more information about the requirements for 'notes'
    content.

    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 not meant to be shown to humans.
    The element's content type is XML type '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.  As is the case with 'notes', it
    is important to refer to the SBML specification document corresponding
    to the SBML Level and Version of your model for more information about
    the requirements for 'annotation' content.

    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 critical that data essential to a model
    definition or that can be encoded in existing SBML elements is not
    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.

    SBML Level 2 introduced an optional SBase attribute named 'metaid' for
    supporting metadata annotations using RDF (Resource Description
    Format). The attribute value has the data type XML ID, 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 XML ID, not just the 'metaid'
    attribute used by SBML---something to be aware of if your application-
    specific XML content inside the 'annotation' subelement happens to use
    XML ID.)  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 2, SBase 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 'int,' and SBO identifiers are stored simply as
    integers. (For convenience, SBase offers methods for returning both
    the integer form and a text-string form of the SBO identifier.)  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'.  More details can be found in SBML
    specifications for Level 2 Version 2 and above.

    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.

    Standard format for annotations linking data resources
    ======================================================================

    SBML Level 2 Versions 2, 3 and 4, and Level 3, 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(SBase self) -> SBase


        Creates and returns a deep copy of this SBase object.

        Returns the (deep) copy of this SBase object.

        """
        return _libsbml.SBase_clone(self)


    def getElementBySId(self, *args):
        """
        getElementBySId(SBase self, string id) -> SBase
        getElementBySId(SBase self, string id) -> SBase


        Returns the first child element found that has the given 'id' in the
        model-wide 'SId' namespace, or 'None' if no such object is found.

        Parameter 'id' is string representing the 'id' attribute value of the
        object to find.

        Returns pointer to the first element found with the given identifier.

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


    def getElementByMetaId(self, *args):
        """
        getElementByMetaId(SBase self, string metaid) -> SBase
        getElementByMetaId(SBase self, string metaid) -> SBase


        Returns the first child element it can find with a specific 'metaid'
        attribute value, or 'None' if no such object is found.

        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
        XML ID, the XML identifier type, which means each 'metaid' value must
        be globally unique within an SBML file.  The latter point is
        important, because the uniqueness criterion applies across any
        attribute with type ID anywhere in the file, not just the 'metaid'
        attribute used by SBML---something to be aware of if your application-
        specific XML content inside the 'annotation' subelement happens to use
        the XML ID type.  Although SBML itself specifies the use of XML ID
        only for the 'metaid' attribute, SBML-compatible applications should
        be careful if they use XML ID's in XML portions of a model that are
        not defined by SBML, such as in the application-specific content of
        the 'annotation' subelement.  Finally, note that LibSBML does not
        provide an explicit XML ID data type; it uses ordinary character
        strings, which is easier for applications to support.

        Parameter 'metaid' is string representing the 'metaid' attribute value
        of the object to find.

        Returns pointer to the first element found with the given meta-
        identifier.

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


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(SBase self, string oldid, string newid)


        Replaces all uses of a given 'SIdRef' type attribute value with
        another value.

        In SBML, object identifiers are of a data type called SId. In SBML
        Level 3, an explicit data type called SIdRef was introduced for
        attribute values that refer to SId values; in previous Levels of SBML,
        this data type did not exist and attributes were simply described to
        as 'referring to an identifier', but the effective data type was the
        same as SIdRef in Level 3.  These and other methods of libSBML refer
        to the type SIdRef for all Levels of SBML, even if the corresponding
        SBML specification did not explicitly name the data type.

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas in MathML content, comparing the referenced
        identifiers to the value of 'oldid'.  If any matches are found, the
        matching values are replaced with 'newid'.  The method does not
        descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.SBase_renameSIdRefs(self, oldid, newid)


    def renameMetaIdRefs(self, oldid, newid):
        """
        renameMetaIdRefs(SBase self, string oldid, string newid)


        Replaces all uses of a given meta identifier attribute value with
        another value.

        In SBML, object 'meta' identifiers are of the XML data type ID; the
        SBML object attribute itself is typically named metaid.  All
        attributes that hold values referring to values of type ID are of the
        XML data type IDREF.  They are also sometimes informally referred to
        as 'metaid refs', in analogy to the SBML-defined type SIdRef.

        This method works by looking at all meta-identifier attribute values,
        comparing the identifiers to the value of 'oldid'.  If any matches are
        found, the matching identifiers are replaced with 'newid'.  The method
        does not descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.SBase_renameMetaIdRefs(self, oldid, newid)


    def renameUnitSIdRefs(self, oldid, newid):
        """
        renameUnitSIdRefs(SBase self, string oldid, string newid)


        Replaces all uses of a given 'UnitSIdRef' type attribute value with
        another value.

        In SBML, unit definitions have identifiers of type UnitSId.  In SBML
        Level 3, an explicit data type called UnitSIdRef was introduced for
        attribute values that refer to UnitSId values; in previous Levels of
        SBML, this data type did not exist and attributes were simply
        described to as 'referring to a unit identifier', but the effective
        data type was the same as UnitSIdRef in Level 3.  These and other
        methods of libSBML refer to the type UnitSIdRef for all Levels of
        SBML, even if the corresponding SBML specification did not explicitly
        name the data type.

        This method works by looking at all unit identifier attribute values
        (including, if appropriate, inside mathematical formulas), comparing
        the referenced unit identifiers to the value of 'oldid'.  If any
        matches are found, the matching values are replaced with 'newid'.  The
        method does not descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.SBase_renameUnitSIdRefs(self, oldid, newid)


    def replaceSIDWithFunction(self, id, function):
        """
        replaceSIDWithFunction(SBase self, string id, ASTNode function)


        Internal implementation method.

        """
        return _libsbml.SBase_replaceSIDWithFunction(self, id, function)


    def divideAssignmentsToSIdByFunction(self, id, function):
        """
        divideAssignmentsToSIdByFunction(SBase self, string id, ASTNode function)


        Internal implementation method.

        """
        return _libsbml.SBase_divideAssignmentsToSIdByFunction(self, id, function)


    def multiplyAssignmentsToSIdByFunction(self, id, function):
        """
        multiplyAssignmentsToSIdByFunction(SBase self, string id, ASTNode function)


        Internal implementation method.

        """
        return _libsbml.SBase_multiplyAssignmentsToSIdByFunction(self, id, function)


    def getElementFromPluginsBySId(self, id):
        """
        getElementFromPluginsBySId(SBase self, string id) -> SBase


        Internal implementation method.

        """
        return _libsbml.SBase_getElementFromPluginsBySId(self, id)


    def getElementFromPluginsByMetaId(self, metaid):
        """
        getElementFromPluginsByMetaId(SBase self, string metaid) -> SBase


        Internal implementation method.

        """
        return _libsbml.SBase_getElementFromPluginsByMetaId(self, metaid)


    def hasNonstandardIdentifierBeginningWith(self, prefix):
        """
        hasNonstandardIdentifierBeginningWith(SBase self, string prefix) -> bool


        Internal implementation method.

        """
        return _libsbml.SBase_hasNonstandardIdentifierBeginningWith(self, prefix)


    def prependStringToAllIdentifiers(self, prefix):
        """
        prependStringToAllIdentifiers(SBase self, string prefix) -> int


        Internal implementation method.

        """
        return _libsbml.SBase_prependStringToAllIdentifiers(self, prefix)


    def transformIdentifiers(self, idTransformer):
        """
        transformIdentifiers(SBase self, IdentifierTransformer idTransformer) -> int


        Internal implementation method.

        """
        return _libsbml.SBase_transformIdentifiers(self, idTransformer)


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


        Returns 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
        XML ID, the XML identifier type, which means each 'metaid' value must
        be globally unique within an SBML file.  The latter point is
        important, because the uniqueness criterion applies across any
        attribute with type ID anywhere in the file, not just the 'metaid'
        attribute used by SBML---something to be aware of if your application-
        specific XML content inside the 'annotation' subelement happens to use
        the XML ID type.  Although SBML itself specifies the use of XML ID
        only for the 'metaid' attribute, SBML-compatible applications should
        be careful if they use XML ID's in XML portions of a model that are
        not defined by SBML, such as in the application-specific content of
        the 'annotation' subelement.  Finally, note that LibSBML does not
        provide an explicit XML ID data type; it uses ordinary character
        strings, which is easier for applications to support.

        Returns the meta-identifier of this SBML object.

        See also isSetMetaId(), setMetaId().

        """
        return _libsbml.SBase_getMetaId(self)


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


        Returns the value of the 'id' attribute of this SBML object, if it has
        one,  or the 'variable' attribute of a Rule, or the 'symbol' attribute
        of an InitialAssignment.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns the id of this SBML object, or the 'variable' if the object is
        a Rule, or the 'symbol' if the object is an InitialAssignment.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, callers should use getIdAttribute()
        instead.

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.SBase_getId(self)


    def getIdAttribute(self):
        """
        getIdAttribute(SBase self) -> string


        Returns the value of the 'id' attribute of this SBML object.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns the id of this SBML object, if set and valid for this level
        and version of SBML; an empty string otherwise.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, callers should use getIdAttribute()
        instead.

        See also setIdAttribute(), isSetIdAttribute(), unsetIdAttribute().

        """
        return _libsbml.SBase_getIdAttribute(self)


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


        Returns the value of the 'name' attribute of this SBML object.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns the name of this SBML object, or the empty string if not set
        or unsettable.

        See also getIdAttribute(), isSetName(), setName(), unsetName().

        """
        return _libsbml.SBase_getName(self)


    def getNotes(self, *args):
        """
        getNotes(SBase self) -> XMLNode
        getNotes(SBase self) -> XMLNode


        Returns the content of the 'notes' subelement of this object as a tree
        of XMLNode objects.

        The optional SBML element named 'notes', present on every major SBML
        component type (and in SBML Level 3, the 'message' subelement of
        Constraint), 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 conform to the definition of XHTML 1.0.
        However, the content cannot be entirely free-form; it must satisfy
        certain requirements defined in the SBML specifications for specific
        SBML Levels.  To help verify the formatting of 'notes' content,
        libSBML provides the static utility method
        SyntaxChecker.hasExpectedXHTMLSyntax(); this method implements a
        verification process that lets callers check whether the content of a
        given XMLNode object conforms to the SBML requirements for 'notes' and
        'message' structure.  Developers are urged to consult the appropriate
        SBML specification document for the Level and Version of their model
        for more in-depth explanations of using 'notes' in SBML.  The SBML
        Level 2 and 3 specifications have considerable detail about how
        'notes' element content must be structured.

        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.  For an alternative method of accessing the notes, see
        getNotesString().

        Returns the content of the 'notes' subelement of this SBML object as a
        tree structure composed of XMLNode objects.

        See also getNotesString(), isSetNotes(), setNotes(), setNotes(),
        appendNotes(), appendNotes(), unsetNotes(),
        SyntaxChecker.hasExpectedXHTMLSyntax().

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


    def getNotesString(self, *args):
        """
        getNotesString(SBase self) -> string
        getNotesString(SBase self) -> string


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

        The optional SBML element named 'notes', present on every major SBML
        component type (and in SBML Level 3, the 'message' subelement of
        Constraint), 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 conform to the definition of XHTML 1.0.
        However, the content cannot be entirely free-form; it must satisfy
        certain requirements defined in the SBML specifications for specific
        SBML Levels.  To help verify the formatting of 'notes' content,
        libSBML provides the static utility method
        SyntaxChecker.hasExpectedXHTMLSyntax(); this method implements a
        verification process that lets callers check whether the content of a
        given XMLNode object conforms to the SBML requirements for 'notes' and
        'message' structure.  Developers are urged to consult the appropriate
        SBML specification document for the Level and Version of their model
        for more in-depth explanations of using 'notes' in SBML.  The SBML
        Level 2 and 3 specifications have considerable detail about how
        'notes' element content must be structured.

        For an alternative method of accessing the notes, see getNotes(),
        which returns the content as an XMLNode tree structure.  Depending on
        an application's needs, one or the other method may be more
        convenient.

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

        See also getNotes(), isSetNotes(), setNotes(), setNotes(),
        appendNotes(), appendNotes(), unsetNotes(),
        SyntaxChecker.hasExpectedXHTMLSyntax().

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


    def getAnnotation(self, *args):
        """
        getAnnotation(SBase self) -> XMLNode
        getAnnotation(SBase self) -> XMLNode


        Returns the content of the 'annotation' subelement of this object as a
        tree of XMLNode objects.

        Whereas the SBML 'notes' subelement is a container for content to be
        shown directly to humans, the 'annotation' element is a container for
        optional software-generated content 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 'any', 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.

        Returns the annotation of this SBML object as a tree of XMLNode
        objects.

        See also getAnnotationString(), isSetAnnotation(), setAnnotation(),
        setAnnotation(), appendAnnotation(), appendAnnotation(),
        unsetAnnotation().

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


    def getAnnotationString(self, *args):
        """
        getAnnotationString(SBase self) -> string
        getAnnotationString(SBase self) -> string


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

        Whereas the SBML 'notes' subelement is a container for content to be
        shown directly to humans, the 'annotation' element is a container for
        optional software-generated content 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 'any', 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.  See
        the method getAnnotation() for a version that returns annotations in
        XML form.

        Returns the annotation of this SBML object as a character string.

        See also getAnnotation(), isSetAnnotation(), setAnnotation(),
        setAnnotation(), appendAnnotation(), appendAnnotation(),
        unsetAnnotation().

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


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


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

        The SBMLNamespaces object encapsulates SBML Level/Version/namespaces
        information.  It is used to communicate the SBML Level, Version, and
        (in Level 3) packages used in addition to SBML Level 3 Core.

        Returns the XML Namespaces associated with this SBML object, or 'None'
        in certain very usual circumstances where a namespace is not set.

        See also getLevel(), getVersion().

        """
        return _libsbml.SBase_getNamespaces(self)


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


        Returns the SBMLDocument object containing this object instance.

        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
        SBML defined in the SBML Level 3 and Level 2 specifications, but it
        does not have a direct correspondence in SBML Level 1.  (But, it is
        created by libSBML no matter whether the model is Level 1, Level 2 or
        Level 3.)

        This method allows the caller to obtain the SBMLDocument for the
        current object.

        Returns the parent SBMLDocument object of this SBML object.

        See also getParentSBMLObject(), getModel().

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


    def getParentSBMLObject(self, *args):
        """
        getParentSBMLObject(SBase self) -> SBase
        getParentSBMLObject(SBase self) -> SBase


        Returns the parent SBML object containing this object.

        This returns the immediately-containing object.  This method is
        convenient when holding an object nested inside other objects in an
        SBML model.

        Returns the parent SBML object of this SBML object.

        See also getSBMLDocument(), getModel().

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


    def getAncestorOfType(self, *args):
        """
        getAncestorOfType(SBase self, int type, string pkgName) -> SBase
        getAncestorOfType(SBase self, int type) -> SBase
        getAncestorOfType(SBase self, int type, string pkgName) -> SBase
        getAncestorOfType(SBase self, int type) -> SBase


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getAncestorOfType(int type, string pkgName = 'core')

        Returns the first ancestor object that has the given SBML type code
        from the given package.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are known as SBML type codes.  In the Python language interface
        for libSBML, the type codes are defined as static integer constants in
        the interface class 'libsbml'.  The names of the type codes all begin
        with the characters 'SBML_.'

        This method searches the tree of objects that are parents of this
        object, and returns the first one that has the given SBML type code
        from  the given 'pkgName'.

        Parameter 'type' is the SBML type code of the object sought.

        Parameter 'pkgName' is (optional) the short name of an SBML Level 3
        package to which the sought-after object must belong.

        Returns the ancestor SBML object of this SBML object that corresponds
        to the given SBML object type code, or 'None' if no ancestor exists.

        WARNING:

        The optional argument 'pkgName' must be used for all type codes from
        SBML Level 3 packages.  Otherwise, the function will search the
        'core' namespace alone, not find any corresponding elements, and
        return  None.

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            getAncestorOfType(int type, string pkgName = 'core')

        Returns the first ancestor object that has the given SBML type code
        from the given package.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are known as SBML type codes.  In the Python language interface
        for libSBML, the type codes are defined as static integer constants in
        the interface class 'libsbml'.  The names of the type codes all begin
        with the characters 'SBML_.'

        This method searches the tree of objects that are parents of this
        object, and returns the first one that has the given SBML type code
        from  the given 'pkgName'.

        Parameter 'type' is the SBML type code of the object sought.

        Parameter 'pkgName' is (optional) the short name of an SBML Level 3
        package to which the sought-after object must belong.

        Returns the ancestor SBML object of this SBML object that corresponds
        to the given SBML object type code, or 'None' if no ancestor exists.

        WARNING:

        The optional argument 'pkgName' must be used for all type codes from
        SBML Level 3 packages.  Otherwise, the function will search the
        'core' namespace alone, not find any corresponding elements, and
        return  None.

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

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


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


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

        Beginning with SBML Level 2 Version 2, objects derived from SBase
        have 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 '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'. More details can be found in SBML
        specifications for Level 2 Version 2 and above.

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

        """
        return _libsbml.SBase_getSBOTerm(self)


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


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

        Beginning with SBML Level 2 Version 2, objects derived from SBase
        have 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 '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'. More details can be found in SBML
        specifications for Level 2 Version 2 and above.

        Returns the value of the 'sboTerm' attribute as a string (its value
        will be of the form 'SBO:NNNNNNN'), or an empty string if the value is
        not set.

        """
        return _libsbml.SBase_getSBOTermID(self)


    def getSBOTermAsURL(self):
        """
        getSBOTermAsURL(SBase self) -> string


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

        This method returns the entire SBO identifier as a text string in the
        form http://identifiers.org/biomodels.sbo/SBO:NNNNNNN'.

        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'. More details can be found in SBML
        specifications for Level 2 Version 2 and above.

        Returns the value of the 'sboTerm' attribute as an identifiers.org
        URL, or an empty string if the value is not set.

        """
        return _libsbml.SBase_getSBOTermAsURL(self)


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


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

        Returns the line number of this SBML object.  If this object was
        created programmatically and not read from a file, this method will
        return the value '0.'

        Note: The line number for each construct in an SBML model is set upon
        reading the model.  The accuracy of the line number depends on the
        correctness of the XML representation of the model, and on the
        particular XML parser library being used.  The former limitation
        relates to the following problem: if the model is actually invalid
        XML, then the parser may not be able to interpret the data correctly
        and consequently may not be able to establish the real line number.
        The latter limitation is simply that different parsers seem to have
        their own accuracy limitations, and out of all the parsers supported
        by libSBML, none have been 100% accurate in all situations. (At this
        time, libSBML supports the use of libxml2, Expat and Xerces.)

        See also getColumn().

        """
        return _libsbml.SBase_getLine(self)


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


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

        Returns the column number of this SBML object.  If this object was
        created programmatically and not read from a file, this method will
        return the value '0.'

        Note: The column number for each construct in an SBML model is set
        upon reading the model.  The accuracy of the column number depends on
        the correctness of the XML representation of the model, and on the
        particular XML parser library being used.  The former limitation
        relates to the following problem: if the model is actually invalid
        XML, then the parser may not be able to interpret the data correctly
        and consequently may not be able to establish the real column number.
        The latter limitation is simply that different parsers seem to have
        their own accuracy limitations, and out of all the parsers supported
        by libSBML, none have been 100% accurate in all situations. (At this
        time, libSBML supports the use of libxml2, Expat and Xerces.)

        See also getLine().

        """
        return _libsbml.SBase_getColumn(self)


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


        Returns the ModelHistory object, if any, attached to this object.

        Returns the ModelHistory object attached to this object, or 'None' if
        none exist.

        Note: In SBML Level 2, model history annotations were only permitted
        on the Model element.  In SBML Level 3, they are permitted on all SBML
        components derived from SBase.

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


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


        Predicate returning 'True' if this object's 'metaid' attribute is 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
        XML ID, the XML identifier type, which means each 'metaid' value must
        be globally unique within an SBML file.  The latter point is
        important, because the uniqueness criterion applies across any
        attribute with type ID anywhere in the file, not just the 'metaid'
        attribute used by SBML---something to be aware of if your application-
        specific XML content inside the 'annotation' subelement happens to use
        the XML ID type.  Although SBML itself specifies the use of XML ID
        only for the 'metaid' attribute, SBML-compatible applications should
        be careful if they use XML ID's in XML portions of a model that are
        not defined by SBML, such as in the application-specific content of
        the 'annotation' subelement.  Finally, note that LibSBML does not
        provide an explicit XML ID data type; it uses ordinary character
        strings, which is easier for applications to support.

        Returns 'True' if the 'metaid' attribute of this SBML object is set,
        'False' otherwise.

        See also getMetaId(), setMetaId().

        """
        return _libsbml.SBase_isSetMetaId(self)


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


        Predicate returning 'True' if a call to getId() returns a non-empty
        string.

        For most objects, this function will return 'True' if its 'id'
        attribute is set, and 'False' if it is not, or if the object has no
        'id' attribute at all.  However, for an EventAssignment or a Rule,
        isSetId() checks whether the 'variable' attribute is set, and for an
        InitialAssignment, it checks whether the 'symbol' attribute is set.
        Because those elements will also have an 'id' attribute in SBML Level
        3 Version 2 which isSetId() will not check, the function itself is
        deprecated, and it is recommended to use isSetIdAttribute() in all
        cases where one needs to know whether the 'id' attribute is set, and
        to use EventAssignment.isSetVariable(), Rule.isSetVariable() and
        InitialAssignment.isSetSymbol() when the status of the 'variable' or
        'symbol' attributes need to be checked.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns 'True' if the 'id' attribute of this SBML object is set,
        'False' otherwise.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is recommended that callers use
        isSetIdAttribute() instead.

        See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(),
        isSetIdAttribute().

        """
        return _libsbml.SBase_isSetId(self)


    def isSetIdAttribute(self):
        """
        isSetIdAttribute(SBase self) -> bool


        Predicate returning 'True' if this object's 'id' attribute is set.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns 'True' if the 'id' attribute of this SBML object is set,
        'False' otherwise.

        See also getIdAttribute(), setIdAttribute(), unsetIdAttribute().

        """
        return _libsbml.SBase_isSetIdAttribute(self)


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


        Predicate returning 'True' if this object's 'name' attribute is set.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns 'True' if the 'name' attribute of this SBML object is set,
        'False' otherwise.

        See also getName(), setName(), unsetName().

        """
        return _libsbml.SBase_isSetName(self)


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


        Predicate returning 'True' if this object's 'notes' subelement exists
        and has content.

        The optional SBML 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.  To help verify the
        formatting of 'notes' content, libSBML provides the static utility
        method SyntaxChecker.hasExpectedXHTMLSyntax(); however, readers are
        urged to consult the appropriate SBML specification document for the
        Level and Version of their model for more in-depth explanations.  The
        SBML Level 2 and 3 specifications have considerable detail about how
        'notes' element content must be structured.

        Returns 'True' if a 'notes' subelement exists, 'False' otherwise.

        See also getNotes(), getNotesString(), setNotes(), setNotes(),
        appendNotes(), appendNotes(), unsetNotes(),
        SyntaxChecker.hasExpectedXHTMLSyntax().

        """
        return _libsbml.SBase_isSetNotes(self)


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


        Predicate returning 'True' if 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 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 'any', 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.

        Returns 'True' if a 'annotation' subelement exists, 'False' otherwise.

        See also getAnnotation(), getAnnotationString(), setAnnotation(),
        setAnnotation(), appendAnnotation(), appendAnnotation(),
        unsetAnnotation().

        """
        return _libsbml.SBase_isSetAnnotation(self)


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


        Predicate returning 'True' if this object's 'sboTerm' attribute is
        set.

        Returns 'True' if the 'sboTerm' attribute of this SBML object is set,
        'False' otherwise.

        """
        return _libsbml.SBase_isSetSBOTerm(self)


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


        Sets the value of the meta-identifier 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
        XML ID, the XML identifier type, which means each 'metaid' value must
        be globally unique within an SBML file.  The latter point is
        important, because the uniqueness criterion applies across any
        attribute with type ID anywhere in the file, not just the 'metaid'
        attribute used by SBML---something to be aware of if your application-
        specific XML content inside the 'annotation' subelement happens to use
        the XML ID type.  Although SBML itself specifies the use of XML ID
        only for the 'metaid' attribute, SBML-compatible applications should
        be careful if they use XML ID's in XML portions of a model that are
        not defined by SBML, such as in the application-specific content of
        the 'annotation' subelement.  Finally, note that LibSBML does not
        provide an explicit XML ID data type; it uses ordinary character
        strings, which is easier for applications to support.

        The string 'metaid' is copied.

        Parameter 'metaid' is the identifier string to use as the value of the
        'metaid' attribute.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        See also getMetaId(), isSetMetaId().

        """
        return _libsbml.SBase_setMetaId(self, metaid)


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


        Predicate returning 'True' if this object has a ModelHistory object
        attached to it.

        Returns 'True' if the ModelHistory of this object is set, 'False'
        otherwise.

        Note: In SBML Level 2, model history annotations were only permitted
        on the Model element.  In SBML Level 3, they are permitted on all SBML
        components derived from SBase.

        """
        return _libsbml.SBase_isSetModelHistory(self)


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


        Sets the value of the 'id' attribute of this SBML object.

        The string 'sid' is copied.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Parameter 'sid' is the string to use as the identifier of this object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.SBase_setId(self, sid)


    def setIdAttribute(self, sid):
        """
        setIdAttribute(SBase self, string sid) -> int


        Sets the value of the 'id' attribute of this SBML object.

        The string 'sid' is copied.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Parameter 'sid' is the string to use as the identifier of this object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.SBase_setIdAttribute(self, sid)


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


        Sets the value of the 'name' attribute of this SBML object.

        The string in 'name' is copied.

        Parameter 'name' is the new name for the SBML object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.SBase_setName(self, name)


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            setAnnotation(XMLNode annotation)

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

        The content of 'annotation' is copied, and any previous content of
        this object's 'annotation' subelement is deleted.

        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 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 'any', 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
        '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() or SBase.appendAnnotation().

        Parameter 'annotation' is an XML structure that is to be used as the
        new content of the 'annotation' subelement of this object.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        See also getAnnotationString(), isSetAnnotation(), setAnnotation(),
        appendAnnotation(), appendAnnotation(), unsetAnnotation().

        ______________________________________________________________________
        Method variant with the following signature:

            setAnnotation(string annotation)

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

        The content of 'annotation' is copied, and any previous content of
        this object's 'annotation' subelement is deleted.

        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 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 'any', 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
        '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() or SBase.appendAnnotation().

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

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getAnnotationString(), isSetAnnotation(), setAnnotation(),
        appendAnnotation(), appendAnnotation(), unsetAnnotation().

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


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            appendAnnotation(XMLNode annotation)

        Appends the given 'annotation' to 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 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 'any', 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() or SBase.setAnnotation(), this method
        allows other annotations to be preserved when an application adds its
        own data.

        Parameter 'annotation' is an XML structure that is to be copied and
        appended to the content of the 'annotation' subelement of this object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_UNEXPECTED_ATTRIBUTE (if the parent element does not have
        the 'metaid' attribute set)

        * LIBSBML_DUPLICATE_ANNOTATION_NS (if the parent was already
        annotated with the annotation in question)

        See also getAnnotationString(), isSetAnnotation(), setAnnotation(),
        setAnnotation(), appendAnnotation(), unsetAnnotation().

        ______________________________________________________________________
        Method variant with the following signature:

            appendAnnotation(string annotation)

        Appends the given 'annotation' to 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 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 'any', 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() or SBase.setAnnotation(), this method
        allows other annotations to be preserved when an application adds its
        own data.

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

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_UNEXPECTED_ATTRIBUTE (if the parent element does not have
        the 'metaid' attribute set)

        * LIBSBML_DUPLICATE_ANNOTATION_NS (if the parent was already
        annotated with the annotation in question)

        See also getAnnotationString(), isSetAnnotation(), setAnnotation(),
        setAnnotation(), appendAnnotation(), unsetAnnotation().

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


    def removeTopLevelAnnotationElement(self, *args):
        """
        removeTopLevelAnnotationElement(SBase self, string elementName, string elementURI, bool removeEmpty=True) -> int
        removeTopLevelAnnotationElement(SBase self, string elementName, string elementURI) -> int
        removeTopLevelAnnotationElement(SBase self, string elementName) -> int


        Removes the top-level element within the 'annotation' subelement of
        this SBML object with the given name and optional URI.

        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.

        Calling this method allows a particular annotation element to be
        removed whilst the remaining annotations remain intact.

        Parameter 'elementName' is a string representing the name of the top
        level annotation element that is to be removed. Parameter 'elementURI'
        is an optional string that is used to check both the name and URI of
        the top level element to be removed. Parameter 'removeEmpty' is if
        after removing of the element, the annotation is  empty, and the
        removeEmpty argument is true, the annotation node will be  deleted
        (default).

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_ANNOTATION_NAME_NOT_FOUND

        * LIBSBML_ANNOTATION_NS_NOT_FOUND

        See also replaceTopLevelAnnotationElement(),
        replaceTopLevelAnnotationElement().

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

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


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            replaceTopLevelAnnotationElement(XMLNode annotation)

        Replaces the given top-level element within the 'annotation'
        subelement of this SBML object and with the annotation element
        supplied.

        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.

        This method determines the name of the element to be replaced from the
        annotation argument. Functionally it is equivalent to calling
        removeTopLevelAnnotationElement(name) followed by calling
        appendAnnotation(annotation_with_name), with the exception that the
        placement of the annotation element remains the same.

        Parameter 'annotation' is XMLNode representing the replacement top
        level annotation.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        See also removeTopLevelAnnotationElement(),
        replaceTopLevelAnnotationElement().

        ______________________________________________________________________
        Method variant with the following signature:

            replaceTopLevelAnnotationElement(string annotation)

        Replaces the given top-level element within the 'annotation'
        subelement of this SBML object and with the annotation element
        supplied.

        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.

        This method determines the name of the element to be replaced from the
        annotation argument. Functionally it is equivalent to calling
        removeTopLevelAnnotationElement(name) followed by calling
        appendAnnotation(annotation_with_name), with the exception that the
        placement of the annotation element remains the same.

        Parameter 'annotation' is string representing the replacement top
        level annotation.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        See also removeTopLevelAnnotationElement(),
        replaceTopLevelAnnotationElement().

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


    def setNotes(self, *args):
        """
        setNotes(SBase self, XMLNode notes) -> int
        setNotes(SBase self, string notes, bool addXHTMLMarkup=False) -> int
        setNotes(SBase self, string notes) -> int


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            setNotes(string notes, bool addXHTMLMarkup = false)

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

        The content of 'notes' is copied, and any existing content of this
        object's 'notes' subelement is deleted.

        The optional SBML 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.  To help verify the
        formatting of 'notes' content, libSBML provides the static utility
        method SyntaxChecker.hasExpectedXHTMLSyntax(); however, readers are
        urged to consult the appropriate SBML specification document for the
        Level and Version of their model for more in-depth explanations.  The
        SBML Level 2 and 3 specifications have considerable detail about how
        'notes' element content must be structured.

        The following code illustrates a very simple way of setting the notes
        using this method.  Here, the object being annotated is the whole SBML
        document, but that is for illustration purposes only; you could of
        course use this same approach to annotate any other SBML component.

          try:
            sbmlDoc = SBMLDocument(3, 1)
          except ValueError:
            print('Could not create SBMLDocument object')
            sys.exit(1)

          note = '<body xmlns='http://www.w3.org/1999/xhtml'><p>here is my note</p></body>'

          status = sbmlDoc.setNotes(note)
          if status != LIBSBML_OPERATION_SUCCESS:
            # Do something to handle the error here.
            print('Unable to set notes on the SBML document object')
            sys.exit(1)

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

        Parameter 'addXHTMLMarkup' is a boolean indicating whether to wrap the
        contents of the 'notes' argument with XHTML paragraph (<p>) tags.
        This is appropriate when the string in 'notes' does not already
        containg the appropriate XHTML markup.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_OPERATION_FAILED

        See also getNotesString(), isSetNotes(), setNotes(), appendNotes(),
        appendNotes(), unsetNotes(), SyntaxChecker.hasExpectedXHTMLSyntax().

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            setNotes(XMLNode notes)

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

        The content of 'notes' is copied, and any existing content of this
        object's 'notes' subelement is deleted.

        The optional SBML 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.  To help verify the
        formatting of 'notes' content, libSBML provides the static utility
        method SyntaxChecker.hasExpectedXHTMLSyntax(); however, readers are
        urged to consult the appropriate SBML specification document for the
        Level and Version of their model for more in-depth explanations.  The
        SBML Level 2 and 3 specifications have considerable detail about how
        'notes' element content must be structured.

        Parameter 'notes' is an XML structure that is to be used as the
        content of the 'notes' subelement of this object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_OBJECT

        See also getNotesString(), isSetNotes(), setNotes(), appendNotes(),
        appendNotes(), unsetNotes(), SyntaxChecker.hasExpectedXHTMLSyntax().

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


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            appendNotes(string notes)

        Appends the given 'notes' to the 'notes' subelement of this object.

        The content of the parameter 'notes' is copied.

        The optional SBML 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.  To help verify the
        formatting of 'notes' content, libSBML provides the static utility
        method SyntaxChecker.hasExpectedXHTMLSyntax(); however, readers are
        urged to consult the appropriate SBML specification document for the
        Level and Version of their model for more in-depth explanations.  The
        SBML Level 2 and 3 specifications have considerable detail about how
        'notes' element content must be structured.

        Parameter 'notes' is an XML string that is to appended to the content
        of the 'notes' subelement of this object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_OPERATION_FAILED

        See also getNotesString(), isSetNotes(), setNotes(), setNotes(),
        appendNotes(), unsetNotes(), SyntaxChecker.hasExpectedXHTMLSyntax().

        ______________________________________________________________________
        Method variant with the following signature:

            appendNotes(XMLNode notes)

        Appends the given 'notes' to the 'notes' subelement of this object.

        The content of 'notes' is copied.

        The optional SBML 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.  To help verify the
        formatting of 'notes' content, libSBML provides the static utility
        method SyntaxChecker.hasExpectedXHTMLSyntax(); however, readers are
        urged to consult the appropriate SBML specification document for the
        Level and Version of their model for more in-depth explanations.  The
        SBML Level 2 and 3 specifications have considerable detail about how
        'notes' element content must be structured.

        Parameter 'notes' is an XML node structure that is to appended to the
        content of the 'notes' subelement of this object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_OPERATION_FAILED

        See also getNotesString(), isSetNotes(), setNotes(), setNotes(),
        appendNotes(), unsetNotes(), SyntaxChecker.hasExpectedXHTMLSyntax().

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


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


        Sets the ModelHistory of this object.

        The content of 'history' is copied, and this object's existing model
        history content is deleted.

        Parameter 'history' is ModelHistory of this object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        * LIBSBML_INVALID_OBJECT

        Note: In SBML Level 2, model history annotations were only permitted
        on the Model element.  In SBML Level 3, they are permitted on all SBML
        components derived from SBase.

        """
        return _libsbml.SBase_setModelHistory(self, history)


    def connectToParent(self, parent):
        """
        connectToParent(SBase self, SBase parent)


        Internal implementation method.

        """
        return _libsbml.SBase_connectToParent(self, parent)


    def connectToChild(self):
        """connectToChild(SBase self)"""
        return _libsbml.SBase_connectToChild(self)


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            setSBOTerm(int value)

        Sets the value of the 'sboTerm' attribute.

        Beginning with SBML Level 2 Version 2, objects derived from SBase
        have 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 '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'. More details can be found in SBML
        specifications for Level 2 Version 2 and above.

        Parameter 'value' is the NNNNNNN integer portion of the SBO
        identifier.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        See also setSBOTerm().

        ______________________________________________________________________
        Method variant with the following signature:

            setSBOTerm(string &sboid)

        Sets the value of the 'sboTerm' attribute by string.

        Beginning with SBML Level 2 Version 2, objects derived from SBase
        have 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 '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'. More details can be found in SBML
        specifications for Level 2 Version 2 and above.

        Parameter 'sboid' is the SBO identifier string of the form
        'SBO:NNNNNNN'.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        See also setSBOTerm().

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


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


        Sets the namespaces relevant of this SBML object.

        The content of 'xmlns' is copied, and this object's existing namespace
        content is deleted.

        The SBMLNamespaces object encapsulates SBML Level/Version/namespaces
        information.  It is used to communicate the SBML Level, Version, and
        (in Level 3) packages used in addition to SBML Level 3 Core.

        Parameter 'xmlns' is the namespaces to set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.SBase_setNamespaces(self, xmlns)


    def unsetMetaId(self):
        """
        unsetMetaId(SBase 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
        XML ID, the XML identifier type, which means each 'metaid' value must
        be globally unique within an SBML file.  The latter point is
        important, because the uniqueness criterion applies across any
        attribute with type ID anywhere in the file, not just the 'metaid'
        attribute used by SBML---something to be aware of if your application-
        specific XML content inside the 'annotation' subelement happens to use
        the XML ID type.  Although SBML itself specifies the use of XML ID
        only for the 'metaid' attribute, SBML-compatible applications should
        be careful if they use XML ID's in XML portions of a model that are
        not defined by SBML, such as in the application-specific content of
        the 'annotation' subelement.  Finally, note that LibSBML does not
        provide an explicit XML ID data type; it uses ordinary character
        strings, which is easier for applications to support.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.SBase_unsetMetaId(self)


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


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

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.SBase_unsetId(self)


    def unsetIdAttribute(self):
        """
        unsetIdAttribute(SBase self) -> int


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

        Most (but not all) objects in SBML include two common attributes: 'id'
        and 'name'.  The identifier given by an object's 'id' attribute value
        is used to identify the object within the SBML model definition. Other
        objects can refer to the component using this identifier.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute().

        """
        return _libsbml.SBase_unsetIdAttribute(self)


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


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

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getName(), setName(), isSetName().

        """
        return _libsbml.SBase_unsetName(self)


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


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

        The optional SBML 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.  To help verify the
        formatting of 'notes' content, libSBML provides the static utility
        method SyntaxChecker.hasExpectedXHTMLSyntax(); however, readers are
        urged to consult the appropriate SBML specification document for the
        Level and Version of their model for more in-depth explanations.  The
        SBML Level 2 and 3 specifications have considerable detail about how
        'notes' element content must be structured.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        See also getNotesString(), isSetNotes(), setNotes(), setNotes(),
        appendNotes(), appendNotes(), SyntaxChecker.hasExpectedXHTMLSyntax().

        """
        return _libsbml.SBase_unsetNotes(self)


    def unsetAnnotation(self):
        """
        unsetAnnotation(SBase 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 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 'any', 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.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        See also getAnnotation(), getAnnotationString(), isSetAnnotation(),
        setAnnotation(), setAnnotation(), appendAnnotation(),
        appendAnnotation().

        """
        return _libsbml.SBase_unsetAnnotation(self)


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


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

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        """
        return _libsbml.SBase_unsetSBOTerm(self)


    def addCVTerm(self, term, newBag=False):
        """
        addCVTerm(SBase self, CVTerm term, bool newBag=False) -> int
        addCVTerm(SBase self, CVTerm term) -> int


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

        Parameter 'term' is the CVTerm to assign.

        Parameter 'newBag' is if 'True,' creates a new RDF bag with the same
        identifier as a previous bag, and if 'False,' adds the term to an
        existing RDF bag with the same type of qualifier as the term being
        added.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_UNEXPECTED_ATTRIBUTE, if this object lacks a 'metaid'
        attribute

        * LIBSBML_INVALID_OBJECT

        Note: Since the CV Term uses the 'metaid' attribute of the object as a
        reference, if the object has no 'metaid' attribute value set, then the
        CVTerm will not be added.

        Note: This method should be used with some caution.  The fact that
        this method copies the object passed to it means that the caller will
        be left holding a physically different object instance than the one
        contained inside this object.  Changes made to the original object
        instance (such as resetting attribute values) will not affect the
        instance in this object.  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 other methods on this class
        (particularly a corresponding method whose name begins with the word
        create) for alternatives that do not lead to these issues.

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        return _libsbml.SBase_addCVTerm(self, term, newBag)


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

      Get the List of CVTerm objects in this element.

      Returns the CVTermList for this element.


      """

      cvlist = _libsbml.SBase_getCVTerms(self)
      if cvlist is None:
        return []
      else:
        return cvlist



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


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

        Returns the number of CVTerms for this SBML object.

        """
        return _libsbml.SBase_getNumCVTerms(self)


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


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

        Parameter 'n' is long the index of the CVTerm to retrieve.

        Returns the nth CVTerm in the list of CVTerms for this SBML object. If
        the index 'n' is invalid, 'None' is returned.

        """
        return _libsbml.SBase_getCVTerm(self, n)


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


        Clears the list of CVTerm objects attached to this SBML object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.SBase_unsetCVTerms(self)


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


        Unsets the ModelHistory object attached to this object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        * LIBSBML_OPERATION_FAILED

        Note: In SBML Level 2, model history annotations were only permitted
        on the Model element.  In SBML Level 3, they are permitted on all SBML
        components derived from SBase.

        """
        return _libsbml.SBase_unsetModelHistory(self)


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


        Returns the MIRIAM biological qualifier associated with the given
        resource.

        In MIRIAM, qualifiers are an optional means of indicating the
        relationship between a model component and its annotations.  There are
        two broad kinds of annotations: model and biological.  The latter kind
        is used to qualify the relationship between a model component and a
        biological entity which it represents.  Examples of relationships
        include 'is' and 'has part', but many others are possible.  MIRIAM
        defines numerous relationship qualifiers to enable different software
        tools to qualify biological annotations in the same standardized way.
        In libSBML, the MIRIAM controlled-vocabulary annotations on an SBML
        model element are represented using lists of CVTerm objects, and the
        the MIRIAM biological qualifiers are represented using values whose
        names begin with BQB_ in the interface class libsbml.

        This method searches the controlled-vocabulary annotations (i.e., the
        list of CVTerm objects) on the present object, then out of those that
        have biological qualifiers, looks for an annotation to the given
        'resource'.  If such an annotation is found, it returns the type of
        biological qualifier associated with that resource as a  value whose
        name begins with BQB_ from the interface class libsbml.

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

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

        Note: The set of MIRIAM biological qualifiers grows over time,
        although relatively slowly.  The values are up to date with MIRIAM at
        the time of a given libSBML release.  The set of values in list of
        BQB_ constants defined in libsbml may be expanded in later libSBML
        releases, to match the values defined by MIRIAM at that later time.

        """
        return _libsbml.SBase_getResourceBiologicalQualifier(self, resource)


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


        Returns the MIRIAM model qualifier associated with the given resource.

        In MIRIAM, qualifiers are an optional means of indicating the
        relationship between a model component and its annotations.  There are
        two broad kinds of annotations: model and biological.  The former kind
        is used to qualify the relationship between a model component and
        another modeling object.  An example qualifier is 'isDerivedFrom', to
        indicate that a given component of the model is derived from the
        modeling object represented by the referenced resource.  MIRIAM
        defines numerous relationship qualifiers to enable different software
        tools to qualify model annotations in the same standardized way.  In
        libSBML, the MIRIAM controlled-vocabulary annotations on an SBML model
        element are represented using lists of CVTerm objects, and the  the
        MIRIAM model qualifiers are represented using values whose names begin
        with BQM_ in the interface class libsbml.

        This method method searches the controlled-vocabulary annotations
        (i.e., the list of CVTerm objects) on the present object, then out of
        those that have model qualifiers, looks for an annotation to the given
        'resource'.  If such an annotation is found, it returns the type of
        type of model qualifier associated with that resource as a  value
        whose name begins with BQM_ from the interface class libsbml.

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

        Returns the model qualifier type associated with the resource, or
        BQM_UNKNOWN if the resource does not exist.

        Note: The set of MIRIAM model qualifiers grows over time, although
        relatively slowly.  The values are up to date with MIRIAM at the time
        of a given libSBML release.  The set of values in list of BQM_
        constants defined in libsbml may be expanded in later libSBML
        releases, to match the values defined by MIRIAM at that later time.

        """
        return _libsbml.SBase_getResourceModelQualifier(self, resource)


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


        Returns the Model object for the SBML Document in which the current
        object is located.

        Returns the Model object for the SBML Document of this SBML object.

        See also getParentSBMLObject(), getSBMLDocument().

        """
        return _libsbml.SBase_getModel(self)


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


        Returns the SBML Level of the SBMLDocument object containing this
        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
        SBML defined in the SBML Level 3 and Level 2 specifications, but it
        does not have a direct correspondence in SBML Level 1.  (But, it is
        created by libSBML no matter whether the model is Level 1, Level 2 or
        Level 3.)

        Returns the SBML level of this SBML object.

        See also getVersion(), getNamespaces(), getPackageVersion().

        """
        return _libsbml.SBase_getLevel(self)


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


        Returns the Version within the SBML Level of the SBMLDocument object
        containing this 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
        SBML defined in the SBML Level 3 and Level 2 specifications, but it
        does not have a direct correspondence in SBML Level 1.  (But, it is
        created by libSBML no matter whether the model is Level 1, Level 2 or
        Level 3.)

        Returns the SBML version of this SBML object.

        See also getLevel(), getNamespaces().

        """
        return _libsbml.SBase_getVersion(self)


    def getPackageCoreVersion(self):
        """
        getPackageCoreVersion(SBase self) -> unsigned int


        Returns the SBML Core Version within the SBML Level of the actual
        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
        SBML defined in the SBML Level 3 and Level 2 specifications, but it
        does not have a direct correspondence in SBML Level 1.  (But, it is
        created by libSBML no matter whether the model is Level 1, Level 2 or
        Level 3.)

        Returns the SBML core version of this SBML object.

        """
        return _libsbml.SBase_getPackageCoreVersion(self)


    def getPackageVersion(self):
        """
        getPackageVersion(SBase self) -> unsigned int


        Returns the Version of the SBML Level 3 package to which this element
        belongs to.

        Returns the version of the SBML Level 3 package to which this element
        belongs. The value '0' will be returned if this element belongs to the
        SBML Level 3 Core package.

        See also getLevel(), getVersion().

        """
        return _libsbml.SBase_getPackageVersion(self)


    def getPackageName(self):
        """
        getPackageName(SBase self) -> string


        Returns the name of the SBML Level 3 package in which this element is
        defined.

        Returns the name of the SBML package in which this element is defined.
        The string "core" will be returned if this element is defined in
        SBML Level 3 Core. The string "unknown" will be returned if this
        element is not defined in any SBML package.

        """
        return _libsbml.SBase_getPackageName(self)


    def getTypeCode(self):
        """
        getTypeCode(SBase self) -> int


        Returns the libSBML type code for this object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Here follow some additional general information about libSBML type
        codes:

        * The codes are the possible return values (integers) for the
        following functions:

        * SBase.getTypeCode()

        * ListOf.getItemTypeCode() (Compatibility note: in libSBML 5, the
        type of return values of these functions changed from an enumeration
        to an integer for extensibility in the face of different programming
        languages.)

        * Each package extension must define similar sets of values for
        each SBase subclass (e.g. SBMLLayoutTypeCode_t for the SBML Level 3
        Layout extension, SBMLFbcTypeCode_t for the SBML Level 3 Flux Balance
        Constraints extension, etc.).

        * The value of each package-specific type code can be duplicated
        between those of different packages.  (This is necessary because the
        development of libSBML extensions for different SBML packages may be
        undertaken by different developers at different times; requiring the
        developers to coordinate their use of type codes would be nettlesome
        and probably doomed to failure.)

        * To distinguish between the type codes of different packages,
        both the return value of SBase.getTypeCode() and
        SBase.getPackageName() must be checked.  This is particularly
        important for functions that take an SBML type code as an argument,
        such as SBase.getAncestorOfType(), which by default assumes you are
        handing it a core type, and will return 'None' if the value you give
        it is actually from a package.

        The following example code illustrates the combined use of
        SBase.getPackageName() and SBase.getTypeCode():

          def example(item):
            pkg_name  = item.getPackageName()
            type_code = item.getTypeCode()
            if pkg_name == 'core':
              print('Got a ' + SBMLTypeCode_toString(type_code, 'core') + ' object')
              if type_code == SBML_MODEL:
                print('This is a very, very nice model')
                # Do whatever the application wants to do with the model.
              elif type_code == SBML_COMPARTMENT:
                print('This is a very, very nice compartment')
                # Do whatever the application wants to do with the compartment.
              elif type_code == SBML_SPECIES:
                print('This is a very, very nice species')
                # Do whatever the application wants to do with the species.
              elif ...
                ...
            elif pkg_name == 'layout':
              print('Got a ' + SBMLTypeCode_toString(type_code, 'layout') + ' object')
              if type_code == SBML_LAYOUT_POINT:
                print('This is a very, very nice layout point')
                # Do whatever the application wants to do with the layout point.
              elif type_code == SBML_LAYOUT_BOUNDINGBOX:
                print('This is a very, very nice layout bounding box')
                # Do whatever the application wants to do with the layout bounding box.
              elif ...
                ...
            elif pkg_name == 'unknown':
              print('Something went wrong -- libSBML did not recognize the object type')
              # Handle errors

        Returns the SBML object type code of this SBML object, or
        SBML_UNKNOWN (the default).  The latter is possible because subclasses
        of SBase are not required to implement this method to return a type
        code.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getPackageName(), getElementName().

        """
        return _libsbml.SBase_getTypeCode(self)


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


        Predicate returning @c true if 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: <code style='margin-right:0; padding-right:0'>http</code><code style='margin-left:0; padding-left:0'>://www.sbml.org/sbml/level1</code>
        <li> Level&nbsp;2 Version&nbsp;1: <code style='margin-right:0; padding-right:0'>http</code><code style='margin-left:0; padding-left:0'>://www.sbml.org/sbml/level2</code>
        <li> Level&nbsp;2 Version&nbsp;2: <code style='margin-right:0; padding-right:0'>http</code><code style='margin-left:0; padding-left:0'>://www.sbml.org/sbml/level2/version2</code>
        <li> Level&nbsp;2 Version&nbsp;3: <code style='margin-right:0; padding-right:0'>http</code><code style='margin-left:0; padding-left:0'>://www.sbml.org/sbml/level2/version3</code>
        <li> Level&nbsp;2 Version&nbsp;4: <code style='margin-right:0; padding-right:0'>http</code><code style='margin-left:0; padding-left:0'>://www.sbml.org/sbml/level2/version4</code>
        <li> Level&nbsp;3 Version&nbsp;1 Core: <code style='margin-right:0; padding-right:0'>http</code><code style='margin-left:0; padding-left:0'>://www.sbml.org/sbml/level3/version1/core</code>
        </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(SBase 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',' and so
        on.

        """
        return _libsbml.SBase_getElementName(self)


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


        Returns a string consisting of a partial SBML corresponding to just
        this object.

        Returns the partial SBML that describes this SBML object.

        WARNING:

        This is primarily provided for testing and debugging purposes.  It may
        be removed in a future version of libSBML.

        """
        return _libsbml.SBase_toSBML(self)


    def toXMLNode(self):
        """
        toXMLNode(SBase self) -> XMLNode


        Returns this element as an XMLNode.

        Returns this element as an XMLNode.

        WARNING:

        This operation is computationally expensive, because the element has
        to be fully serialized to a string and then parsed into the XMLNode
        structure.  Attempting to convert a large tree structure (e.g., a
        large Model) may consume significant computer memory and time.

        """
        return _libsbml.SBase_toXMLNode(self)


    def getPlugin(self, *args):
        """
        getPlugin(SBase self, string package) -> SBasePlugin
        getPlugin(SBase self, string package) -> SBasePlugin
        getPlugin(SBase self, unsigned int n) -> SBasePlugin
        getPlugin(SBase self, unsigned int n) -> SBasePlugin


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getPlugin(long n)

        Returns the nth plug-in object (extension interface) for an SBML Level
        3 package extension. The returned plug-in will be the appropriate type
        of plugin requested: calling Model.getPlugin() will return an
        FbcModelPlugin; calling Parameter.getPlugin() will return
        CompSBasePlugin, etc.

        If no such plugin exists, None is returned.

        SBML Level 3 consists of a Core definition that can be extended via
        optional SBML Level 3 packages.  A given model may indicate that it
        uses one or more SBML packages, and likewise, a software tool may be
        able to support one or more packages.  LibSBML does not come
        preconfigured with all possible packages included and enabled, in part
        because not all package specifications have been finalized.  To
        support the ability for software systems to enable support for the
        Level 3 packages they choose, libSBML features a plug-in mechanism.
        Each SBML Level 3 package is implemented in a separate code plug-in
        that can be enabled by the application to support working with that
        SBML package.  A given SBML model may thus contain not only objects
        defined by SBML Level 3 Core, but also objects created by libSBML
        plug-ins supporting additional Level 3 packages.

        Parameter 'n' is the index of the plug-in to return.

        Returns the nth plug-in object (the libSBML extension interface) of a
        package extension. If the index 'n' is invalid, 'None' is returned.

        See also getNumPlugins(), getPlugin().

        ______________________________________________________________________
        Method variant with the following signature:

            getPlugin(string package)

        Returns a plug-in object (extension interface) for an SBML Level 3
        package extension with the given package name or URI. The returned
        plug-in will be the appropriate type of plugin requested: calling
        Model.getPlugin() will return an FbcModelPlugin; calling
        Parameter.getPlugin() will return CompSBasePlugin, etc.

        If no such plugin exists, None is returned.

        SBML Level 3 consists of a Core definition that can be extended via
        optional SBML Level 3 packages.  A given model may indicate that it
        uses one or more SBML packages, and likewise, a software tool may be
        able to support one or more packages.  LibSBML does not come
        preconfigured with all possible packages included and enabled, in part
        because not all package specifications have been finalized.  To
        support the ability for software systems to enable support for the
        Level 3 packages they choose, libSBML features a plug-in mechanism.
        Each SBML Level 3 package is implemented in a separate code plug-in
        that can be enabled by the application to support working with that
        SBML package.  A given SBML model may thus contain not only objects
        defined by SBML Level 3 Core, but also objects created by libSBML
        plug-ins supporting additional Level 3 packages.

        Parameter 'package' is the name or URI of the package.

        Returns the plug-in object (the libSBML extension interface) of a
        package extension with the given package name or URI.

        See also getPlugin().

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


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


        Returns the nth disabled plug-in object (extension interface) for an
        SBML Level 3 package extension.  If no such plugin exists, None is
        returned.

        SBML Level 3 consists of a Core definition that can be extended via
        optional SBML Level 3 packages.  A given model may indicate that it
        uses one or more SBML packages, and likewise, a software tool may be
        able to support one or more packages.  LibSBML does not come
        preconfigured with all possible packages included and enabled, in part
        because not all package specifications have been finalized.  To
        support the ability for software systems to enable support for the
        Level 3 packages they choose, libSBML features a plug-in mechanism.
        Each SBML Level 3 package is implemented in a separate code plug-in
        that can be enabled by the application to support working with that
        SBML package.  A given SBML model may thus contain not only objects
        defined by SBML Level 3 Core, but also objects created by libSBML
        plug-ins supporting additional Level 3 packages.

        If a plugin is disabled, the package information it contains is no
        longer considered to be part of the SBML document for the purposes of
        searching the document or writing out the document.  However, the
        information is still retained, so if the plugin is enabled again, the
        same information will once again be available, and will be written out
        to the final model.

        Parameter 'n' is the index of the disabled plug-in to return.

        Returns the nth disabled plug-in object (the libSBML extension
        interface) of a package extension. If the index 'n' is invalid, 'None'
        is returned.

        See also getNumDisabledPlugins(), getPlugin().

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


    def getNumPlugins(self):
        """
        getNumPlugins(SBase self) -> unsigned int


        Returns the number of plug-in objects (extenstion interfaces) for SBML
        Level 3 package extensions known.

        SBML Level 3 consists of a Core definition that can be extended via
        optional SBML Level 3 packages.  A given model may indicate that it
        uses one or more SBML packages, and likewise, a software tool may be
        able to support one or more packages.  LibSBML does not come
        preconfigured with all possible packages included and enabled, in part
        because not all package specifications have been finalized.  To
        support the ability for software systems to enable support for the
        Level 3 packages they choose, libSBML features a plug-in mechanism.
        Each SBML Level 3 package is implemented in a separate code plug-in
        that can be enabled by the application to support working with that
        SBML package.  A given SBML model may thus contain not only objects
        defined by SBML Level 3 Core, but also objects created by libSBML
        plug-ins supporting additional Level 3 packages.

        Returns the number of plug-in objects (extension interfaces) of
        package extensions known by this instance of libSBML.

        See also getPlugin().

        """
        return _libsbml.SBase_getNumPlugins(self)


    def getNumDisabledPlugins(self):
        """
        getNumDisabledPlugins(SBase self) -> unsigned int


        Returns the number of disabled plug-in objects (extension interfaces)
        for SBML Level 3 package extensions known.

        SBML Level 3 consists of a Core definition that can be extended via
        optional SBML Level 3 packages.  A given model may indicate that it
        uses one or more SBML packages, and likewise, a software tool may be
        able to support one or more packages.  LibSBML does not come
        preconfigured with all possible packages included and enabled, in part
        because not all package specifications have been finalized.  To
        support the ability for software systems to enable support for the
        Level 3 packages they choose, libSBML features a plug-in mechanism.
        Each SBML Level 3 package is implemented in a separate code plug-in
        that can be enabled by the application to support working with that
        SBML package.  A given SBML model may thus contain not only objects
        defined by SBML Level 3 Core, but also objects created by libSBML
        plug-ins supporting additional Level 3 packages.

        If a plugin is disabled, the package information it contains is no
        longer considered to be part of the SBML document for the purposes of
        searching the document or writing out the document.  However, the
        information is still retained, so if the plugin is enabled again, the
        same information will once again be available, and will be written out
        to the final model.

        Returns the number of disabled plug-in objects (extension interfaces)
        of package extensions known by this instance of libSBML.

        """
        return _libsbml.SBase_getNumDisabledPlugins(self)


    def deleteDisabledPlugins(self, recursive=True):
        """
        deleteDisabledPlugins(SBase self, bool recursive=True)
        deleteDisabledPlugins(SBase self)


        Deletes all information stored in disabled plugins.  If the plugin is
        re-enabled later, it will then not have any previously-stored
        information.

        SBML Level 3 consists of a Core definition that can be extended via
        optional SBML Level 3 packages.  A given model may indicate that it
        uses one or more SBML packages, and likewise, a software tool may be
        able to support one or more packages.  LibSBML does not come
        preconfigured with all possible packages included and enabled, in part
        because not all package specifications have been finalized.  To
        support the ability for software systems to enable support for the
        Level 3 packages they choose, libSBML features a plug-in mechanism.
        Each SBML Level 3 package is implemented in a separate code plug-in
        that can be enabled by the application to support working with that
        SBML package.  A given SBML model may thus contain not only objects
        defined by SBML Level 3 Core, but also objects created by libSBML
        plug-ins supporting additional Level 3 packages.

        If a plugin is disabled, the package information it contains is no
        longer considered to be part of the SBML document for the purposes of
        searching the document or writing out the document.  However, the
        information is still retained, so if the plugin is enabled again, the
        same information will once again be available, and will be written out
        to the final model.

        Parameter 'recursive' is if 'True,' the disabled information will be
        deleted also from all child elements, otherwise only from this SBase
        element.

        See also getNumDisabledPlugins().

        """
        return _libsbml.SBase_deleteDisabledPlugins(self, recursive)


    def enablePackage(self, pkgURI, pkgPrefix, flag):
        """
        enablePackage(SBase self, string pkgURI, string pkgPrefix, bool flag) -> int


        Enables or disables the given SBML Level 3 package on this object.

        This method enables the specified package on this object and other
        objects connected by child-parent links in the same SBMLDocument
        object. This method is the converse of SBase.disablePackage().

        Parameter 'pkgURI' is the URI of the package.

        Parameter 'pkgPrefix' is the XML prefix of the package.

        Parameter 'flag' is whether to enable ('True)' or disable ('False)'
        the package.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_PKG_UNKNOWN

        * LIBSBML_PKG_VERSION_MISMATCH

        * LIBSBML_PKG_CONFLICTED_VERSION

        See also disablePackage().

        """
        return _libsbml.SBase_enablePackage(self, pkgURI, pkgPrefix, flag)


    def disablePackage(self, pkgURI, pkgPrefix):
        """
        disablePackage(SBase self, string pkgURI, string pkgPrefix) -> int


        Disables the given SBML Level 3 package on this object.

        This method disables the specified package on this object and other
        objects connected by child-parent links in the same SBMLDocument
        object.

        An example of when this may be useful is during construction of model
        components when mixing existing and new models.  Suppose your
        application read an SBML document containing a model that used the
        SBML Hierarchical Model Composition ("comp") package, and extracted
        parts of that model in order to construct a new model in memory.  The
        new, in-memory model will not accept a component drawn from an other
        SBMLDocument with different package namespace declarations. You could
        reconstruct the same namespaces in the in-memory model first, but as a
        shortcut, you could also disable the package namespace on the object
        being added.  Here is a code example to help clarify this:

          import sys
          import os.path
          from libsbml import *

          # We read an SBML L3V1 model that uses the 'comp' package.

          doc = readSBML('sbml-file-with-comp-elements.xml');
          if doc.getNumErrors() > 0:
            print('readSBML encountered errors while reading the file.')
            doc.printErrors()
            sys.exit(1)

          # We extract one of the species from the model.

          model = doc.getModel()
          if model == None:
            print('Unable to retrieve Model object')
            sys.exit(1)

          s1 = model.getSpecies(0)
          if s1 == None:
            print('Unable to retrieve Species object')
            sys.exit(1)

          # We construct a new model.
          # This model does not use the 'comp' package.

          try:
            newDoc = SBMLDocument(3, 1)
          except ValueError:
            print('Could not create SBMLDocument object')
            sys.exit(1)

          newModel = newDoc.createModel()
          if newModel == None:
            print('Unable to create new Model object')
            sys.exit(1)

          # The following would normally fail with an error, because
          # addSpecies() would first check that the parent of the given
          # object has namespaces declared, and will discover that s1
          # does but newModel does not.

          #   newModel.addSpecies(s1)

          # However, if we disable the 'comp' package on s1, then the
          # call to addSpecies will work.

          compNS = 'http://www.sbml.org/sbml/level3/version1/comp/version1'
          status = s1.disablePackage(compNS, 'comp')
          if status != LIBSBML_OPERATION_SUCCESS:
            print('Unable to disable package.')
            sys.exit(1)

          newSpecies = newModel.addSpecies(s1)   # This will work now.
          if newSpecies == None:
            print('Could not add Species')       # (This will not happen,
            sys.exit(1)                          # but always check errors.)

        Parameter 'pkgURI' is the URI of the package.

        Parameter 'pkgPrefix' is the XML prefix of the package.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_PKG_UNKNOWN

        * LIBSBML_PKG_VERSION_MISMATCH

        * LIBSBML_PKG_CONFLICTED_VERSION

        See also enablePackage().

        """
        return _libsbml.SBase_disablePackage(self, pkgURI, pkgPrefix)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(SBase self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.SBase_enablePackageInternal(self, pkgURI, pkgPrefix, flag)


    def isPackageURIEnabled(self, pkgURI):
        """
        isPackageURIEnabled(SBase self, string pkgURI) -> bool


        Predicate returning 'True' if an SBML Level 3 package with the given
        URI is enabled with this object.

        Parameter 'pkgURI' is the URI of the package.

        Returns 'True' if the given package is enabled within this object,
        'False' otherwise.

        See also isPackageEnabled().

        """
        return _libsbml.SBase_isPackageURIEnabled(self, pkgURI)


    def isPackageEnabled(self, pkgName):
        """
        isPackageEnabled(SBase self, string pkgName) -> bool


        Predicate returning 'True' if the given SBML Level 3 package is
        enabled with this object.

        The search ignores the package version.

        Parameter 'pkgName' is the name of the package.

        Returns 'True' if the given package is enabled within this object,
        'False' otherwise.

        See also isPackageURIEnabled().

        """
        return _libsbml.SBase_isPackageEnabled(self, pkgName)


    def isPkgURIEnabled(self, pkgURI):
        """
        isPkgURIEnabled(SBase self, string pkgURI) -> bool


        Predicate returning 'True' if an SBML Level 3 package with the given
        URI is enabled with this object.

        Parameter 'pkgURI' is the URI of the package.

        Returns 'True' if the given package is enabled within this object,
        'False' otherwise.

        DEPRECATED. Replaced in libSBML 5.2.0 by SBase.isPackageURIEnabled().

        See also isPkgEnabled().

        """
        return _libsbml.SBase_isPkgURIEnabled(self, pkgURI)


    def isPkgEnabled(self, pkgName):
        """
        isPkgEnabled(SBase self, string pkgName) -> bool


        Predicate returning 'True' if the given SBML Level 3 package is
        enabled with this object.

        The search ignores the package version.

        Parameter 'pkgName' is the name of the package.

        Returns 'True' if the given package is enabled within this object,
        'False' otherwise.

        DEPRECATED. Replaced in libSBML 5.2.0 by SBase.isPackageEnabled().

        See also isPkgURIEnabled().

        """
        return _libsbml.SBase_isPkgEnabled(self, pkgName)


    def writeExtensionElements(self, stream):
        """
        writeExtensionElements(SBase self, XMLOutputStream stream)


        Internal implementation method.

        """
        return _libsbml.SBase_writeExtensionElements(self, stream)


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


        Internal implementation method.

        """
        return _libsbml.SBase_hasRequiredAttributes(self)


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


        Internal implementation method.

        """
        return _libsbml.SBase_hasRequiredElements(self)


    def checkCompatibility(self, object):
        """
        checkCompatibility(SBase self, SBase object) -> int


        Internal implementation method.

        """
        return _libsbml.SBase_checkCompatibility(self, object)


    def setSBMLNamespacesAndOwn(self, disownedNs):
        """
        setSBMLNamespacesAndOwn(SBase self, SBMLNamespaces disownedNs)


        Internal implementation method.

        """
        return _libsbml.SBase_setSBMLNamespacesAndOwn(self, disownedNs)


    def getSBMLNamespaces(self):
        """
        getSBMLNamespaces(SBase self) -> SBMLNamespaces


        Internal implementation method.

        """
        return _libsbml.SBase_getSBMLNamespaces(self)


    def checkMathMLNamespace(self, elem):
        """
        checkMathMLNamespace(SBase self, XMLToken elem) -> string


        Internal implementation method.

        """
        return _libsbml.SBase_checkMathMLNamespace(self, elem)


    def getDerivedUnitDefinition(self):
        """
        getDerivedUnitDefinition(SBase self) -> UnitDefinition


        Internal implementation method.

        """
        return _libsbml.SBase_getDerivedUnitDefinition(self)


    def containsUndeclaredUnits(self):
        """
        containsUndeclaredUnits(SBase self) -> bool


        Internal implementation method.

        """
        return _libsbml.SBase_containsUndeclaredUnits(self)


    def removeFromParentAndDelete(self):
        """
        removeFromParentAndDelete(SBase self) -> int


        Removes this object from its parent.

        If the parent was storing this object as a pointer, it is deleted.  If
        not, it is simply cleared (as in ListOf objects).  This is a pure
        virtual method, as every SBase element has different parents, and
        therefore different methods of removing itself.  Will fail (and not
        delete itself) if it has no parent object.  This function is designed
        to be overridden, but for all objects whose parent is of the class
        ListOf, the default implementation will work.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.SBase_removeFromParentAndDelete(self)


    def matchesSBMLNamespaces(self, *args):
        """
        matchesSBMLNamespaces(SBase self, SBase sb) -> bool
        matchesSBMLNamespaces(SBase self, SBase sb) -> bool


        Returns 'True' if this object's set of XML namespaces are the same as
        the given object's XML namespaces.

        The SBMLNamespaces object encapsulates SBML Level/Version/namespaces
        information.  It is used to communicate the SBML Level, Version, and
        (in Level 3) packages used in addition to SBML Level 3 Core.  A common
        approach to using libSBML's SBMLNamespaces facilities is to create an
        SBMLNamespaces object somewhere in a program once, then hand that
        object as needed to object constructors that accept SBMLNamespaces as
        arguments.

        Parameter 'sb' is an object to compare with respect to namespaces.

        Returns boolean, 'True' if this object's collection of namespaces is
        the same as 'sb's', 'False' otherwise.

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


    def matchesRequiredSBMLNamespacesForAddition(self, *args):
        """
        matchesRequiredSBMLNamespacesForAddition(SBase self, SBase sb) -> bool
        matchesRequiredSBMLNamespacesForAddition(SBase self, SBase sb) -> bool


        Returns 'True' if this object's set of XML namespaces are a subset of
        the given object's XML namespaces.

        The SBMLNamespaces object encapsulates SBML Level/Version/namespaces
        information.  It is used to communicate the SBML Level, Version, and
        (in Level 3) packages used in addition to SBML Level 3 Core.  A common
        approach to using libSBML's SBMLNamespaces facilities is to create an
        SBMLNamespaces object somewhere in a program once, then hand that
        object as needed to object constructors that accept SBMLNamespaces as
        arguments.

        Parameter 'sb' is an object to compare with respect to namespaces.

        Returns boolean, 'True' if this object's collection of namespaces is a
        subset of 'sb's', 'False' otherwise.

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


    def isSetUserData(self):
        """
        isSetUserData(SBase self) -> bool


        Predicate returning true or false depending on whether the user data
        of this element has been set.

        The user data associated with an SBML object can be used by an
        application developer to attach custom information to that object in
        the model.  In case of a deep copy, this data will passed as-is.  The
        data attribute will never be interpreted by libSBML.

        Returns boolean, 'True' if this object's user data has been set,
        'False' otherwise.

        """
        return _libsbml.SBase_isSetUserData(self)


    def unsetUserData(self):
        """
        unsetUserData(SBase self) -> int


        Unsets the user data of this element.

        The user data associated with an SBML object can be used by an
        application developer to attach custom information to that object in
        the model.  In case of a deep copy, this data will passed as-is.  The
        data attribute will never be interpreted by libSBML.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.SBase_unsetUserData(self)


    def getURI(self):
        """
        getURI(SBase self) -> string


        Gets the namespace URI to which this element belongs to.

        For example, all elements that belong to SBML Level 3 Version 1 Core
        must would have the URI
        'http://www.sbml.org/sbml/level3/version1/core'; all elements that
        belong to Layout Extension Version 1 for SBML Level 3 Version 1 Core
        must would have the URI
        'http://www.sbml.org/sbml/level3/version1/layout/version1'.

        This function first returns the URI for this element by looking into
        the SBMLNamespaces object of the document with the its package name.
        If not found, it will then look for the namespace associated with the
        element itself.

        Returns the URI of this element, as a text string.

        See also getSBMLDocument(), getPackageName().

        """
        return _libsbml.SBase_getURI(self)


    def getPrefix(self):
        """
        getPrefix(SBase self) -> string


        Returns the XML namespace prefix of this element.

        This reports the XML namespace prefix chosen for this class of object
        in the current SBML document.  This may be an empty string if the
        component has no explicit prefix (for instance, if it is a core SBML
        object placed in the default SBML namespace of the document).  If it
        is not empty, then it corresponds to the XML namespace prefix used set
        the object, whatever that may be in a given SBML document.

        Returns a text string representing the XML namespace prefix.

        """
        return _libsbml.SBase_getPrefix(self)


    def hasOptionalAttributes(self):
        """
        hasOptionalAttributes(SBase self) -> bool


        Internal implementation method.

        """
        return _libsbml.SBase_hasOptionalAttributes(self)


    def hasOptionalElements(self):
        """
        hasOptionalElements(SBase self) -> bool


        Internal implementation method.

        """
        return _libsbml.SBase_hasOptionalElements(self)


    def updateSBMLNamespace(self, package, level, version):
        """
        updateSBMLNamespace(SBase self, string package, unsigned int level, unsigned int version)


        Internal implementation method.

        """
        return _libsbml.SBase_updateSBMLNamespace(self, package, level, version)


    __metaclass__ = AutoProperty


    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


    def getListOfAllElements(self, *args):
      """
      getListOfAllElements(self) -> SBaseList

      Get the List of all SBase objects in this element.

      Returns the List of all child elements.


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



    def getListOfAllElementsFromPlugins(self, *args):
      """
      getListOfAllElementsFromPlugins(self) -> SBaseList

      Get the List of SBase objects in this elements plugins.

      Returns the SBaseList of all plugins for this element.


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


SBase_swigregister = _libsbml.SBase_swigregister
SBase_swigregister(SBase)

class ListOf(SBase):
    """

    Parent class for libSBML's 'ListOfXYZ' classes.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    The ListOf class in libSBML is a utility class that serves as the
    parent class for implementing the ListOf__ classes.  It provides
    methods for working generically with the various SBML lists of objects
    in a program. LibSBML uses this separate list class rather than
    ordinary Python lists, so that it can provide the methods and features
    associated with SBase.

    Whether a given ListOf element may be empty or not depends on the
    element in question, and on what level and version of SBML it is being
    used for.  For ListOf elements in SBML Level 3 Version 1 and prior, no
    core list and few package lists could be empty.  As of SBML Level 3
    Version 2, the rules were relaxed, and lists were allowed to be empty.
    In libSBML, documents created for Level 3 Version 2 will be written
    with empty ListOf's if that ListOf contains some other 'extra'
    information: an attribute such as metaid or sboTerm, a child '<notes>'
    or '<annotation>', or information from a SBML  Level 3 package.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    """

    __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__(ListOf self, unsigned int level, unsigned int version) -> ListOf
        __init__(ListOf self, unsigned int level) -> ListOf
        __init__(ListOf self) -> ListOf
        __init__(ListOf self, SBMLNamespaces sbmlns) -> ListOf
        __init__(ListOf self, ListOf orig) -> ListOf


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOf(SBMLNamespaces sbmlns)

        Creates a new ListOf with a given SBMLNamespaces object.

        Parameter 'sbmlns' is the set of SBML namespaces that this ListOf
        should contain.

        Note: Bare ListOf objects are impossible to add to SBML models.  The
        ListOf class is simply the base of other classes in libSBML.  Calling
        programs are not intended to create bare ListOf objects themselves.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOf(long level   = SBML_DEFAULT_LEVEL, long version =
        SBML_DEFAULT_VERSION)

        Creates a new ListOf object.

        Parameter 'level' is the SBML Level; if not assigned, defaults to the
        value of SBMLDocument.getDefaultLevel().

        Parameter 'version' is the Version within the SBML Level; if not
        assigned, defaults to the value of SBMLDocument.getDefaultVersion().

        Note: Bare ListOf objects are impossible to add to SBML models.  The
        ListOf class is simply the base of other classes in libSBML.  Calling
        programs are not intended to create bare ListOf objects themselves.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOf(ListOf orig)

        Copy constructor; creates a copy of this ListOf.

        Parameter 'orig' is the ListOf instance to copy.

        """
        this = _libsbml.new_ListOf(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ListOf self) -> ListOf


        Creates and returns a deep copy of this ListOf object.

        Returns the (deep) copy of this ListOf object.

        """
        return _libsbml.ListOf_clone(self)


    def append(self, item):
        """
        append(ListOf self, SBase item) -> int


        Adds an item to the end of this ListOf's list of items.

        This method makes a clone of the 'item' handed to it.  This means that
        when the ListOf object is destroyed, the original items will not be
        destroyed.  For a method with an alternative ownership behavior, see
        the ListOf.appendAndOwn() method.

        Parameter 'item' is the item to be added to the list.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_OBJECT

        See also appendAndOwn(), appendFrom().

        """
        return _libsbml.ListOf_append(self, item)


    def appendAndOwn(self, disownedItem):
        """
        appendAndOwn(ListOf self, SBase disownedItem) -> int


        Adds an item to the end of this ListOf's list of items.

        This method does not clone the 'disownedItem' 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.  For a method
        with an alternative ownership behavior, see the ListOf.append()
        method.

        Parameter 'disownedItem' is the item to be added to the list. Will
        become a child of the parent list.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_OBJECT

        See also append(), appendFrom().

        """
        return _libsbml.ListOf_appendAndOwn(self, disownedItem)


    def appendFrom(self, list):
        """
        appendFrom(ListOf self, ListOf list) -> int


        Adds a clone of a list of items to this ListOf's list.

        Note that because this clones the objects handed to it, the original
        items will not be destroyed when this ListOf object is destroyed.

        Parameter 'list' is a list of items to be added.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_OBJECT

        See also append(), appendAndOwn().

        """
        return _libsbml.ListOf_appendFrom(self, list)


    def insert(self, location, item):
        """
        insert(ListOf self, int location, SBase item) -> int


        Inserts an item at a given position in this ListOf's list of items.

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

        Parameter 'location' is the location in the list where to insert the
        item. Parameter 'item' is the item to be inserted to the list.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_OBJECT

        See also insertAndOwn().

        """
        return _libsbml.ListOf_insert(self, location, item)


    def insertAndOwn(self, location, disownedItem):
        """
        insertAndOwn(ListOf self, int location, SBase disownedItem) -> int


        Inserts an item at a given position in this ListOf's list of items.

        This variant of the method does not make a clone of the 'disownedItem'
        handed to it. This means that when the ListOf is destroyed, the
        original 'item' will be destroyed.

        Parameter 'location' is the location where to insert the item.
        Parameter 'disownedItem' is the item to be inserted to the list. Will
        become a child of the parent list.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_OBJECT

        See also insert().

        """
        return _libsbml.ListOf_insertAndOwn(self, location, disownedItem)


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


        Get an item from the list.

        Parameter 'n' is the index number of the item to get.

        Returns the nth item in this ListOf items, or a null pointer if the
        index number 'n' refers to a nonexistent position in this list.

        See also size().

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


    def getElementBySId(self, id):
        """
        getElementBySId(ListOf self, string id) -> SBase


        Returns the first child element found that has the given identifier.

        This method searches this ListOf's list of items for SBML objects
        based on their 'id' attribute value in the model-wide SId identifier
        namespace.

        Parameter 'id' is string representing the id of the object to find.

        Returns the first element found with the given 'id', or 'None' if no
        such object is found.

        """
        return _libsbml.ListOf_getElementBySId(self, id)


    def getElementByMetaId(self, metaid):
        """
        getElementByMetaId(ListOf self, string metaid) -> SBase


        Returns the first child element found with the given meta-identifier.

        Parameter 'metaid' is string representing the 'metaid' attribute of
        the object to find.

        Returns the first element found with the given 'metaid', or 'None' if
        no such object is found.

        """
        return _libsbml.ListOf_getElementByMetaId(self, metaid)


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


        Removes all items in this ListOf object.

        If parameter '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 cleared only from this
        ListOf object; the caller is still responsible for deleting the actual
        items.  (In the latter case, callers are advised to store pointers to
        all items elsewhere before calling this function.)

        Parameter 'doDelete' is if 'True' (default), all items are deleted and
        cleared. Otherwise, all items are just cleared and not deleted.

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

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


    def removeFromParentAndDelete(self):
        """
        removeFromParentAndDelete(ListOf self) -> int


        Removes all items in this ListOf object and deletes its properties
        too.

        This performs a call to clear() with an argument of 'True' (thus
        removing all the child objects in the list), followed by calls to
        various libSBML unsetFoo methods to delete everything else: CVTerm
        objects, model history objects, etc.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.ListOf_removeFromParentAndDelete(self)


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


        Removes the nth item from this ListOf list of items and returns it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the item to remove.

        See also size().

        """
        return _libsbml.ListOf_remove(self, n)


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


        Returns number of items in this ListOf list.

        Returns the number of items in this ListOf items.

        """
        return _libsbml.ListOf_size(self)


    def connectToChild(self):
        """connectToChild(ListOf self)"""
        return _libsbml.ListOf_connectToChild(self)


    def getTypeCode(self):
        """
        getTypeCode(ListOf self) -> int


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

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_LIST_OF (default).

        Note: The various ListOf classes mostly differ from each other in what
        they contain.  Hence, one must call getItemTypeCode() to fully
        determine the class of this SBML object.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getItemTypeCode(), getElementName(), getPackageName().

        """
        return _libsbml.ListOf_getTypeCode(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOf self) -> int


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

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Classes that inherit from the ListOf class should override this method
        to return the SBML type code for the objects contained in this ListOf.
        If they do not, this method will return SBML_UNKNOWN

        Returns The ListOf base class contains no SBML objects, and therefore
        this method returns SBML_UNKNOWN.

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOf_getItemTypeCode(self)


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


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

        Returns the XML name of this element.

        """
        return _libsbml.ListOf_getElementName(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(ListOf self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.ListOf_enablePackageInternal(self, pkgURI, pkgPrefix, flag)


    def updateSBMLNamespace(self, package, level, version):
        """
        updateSBMLNamespace(ListOf self, string package, unsigned int level, unsigned int version)


        Internal implementation method.

        """
        return _libsbml.ListOf_updateSBMLNamespace(self, package, level, version)


    def hasOptionalElements(self):
        """
        hasOptionalElements(ListOf self) -> bool


        Internal implementation method.

        """
        return _libsbml.ListOf_hasOptionalElements(self)


    def isExplicitlyListed(self):
        """
        isExplicitlyListed(ListOf self) -> bool


        Internal implementation method.

        """
        return _libsbml.ListOf_isExplicitlyListed(self)


    def setExplicitlyListed(self, value=True):
        """
        setExplicitlyListed(ListOf self, bool value=True)
        setExplicitlyListed(ListOf self)


        Internal implementation method.

        """
        return _libsbml.ListOf_setExplicitlyListed(self, value)


    def __len__(self):
        """__len__(ListOf 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):
    """

    An SBML model.

    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 in version 5.18.0

    of libSBML:

    * 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.

    * 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.

    * 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.

    * In SBML Level 3 Version 1, the components are: FunctionDefinition,
    UnitDefinition, Compartment, Species, Parameter, InitialAssignment,
    Rule, Constraint, Reaction and Event.  Instances of the classes are
    placed inside instances of classes ListOfFunctionDefinitions,
    ListOfUnitDefinitions, ListOfCompartments, ListOfSpecies,
    ListOfParameters, ListOfInitialAssignments, ListOfRules,
    ListOfConstraints, ListOfReactions, and ListOfEvents.   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.

    In addition to the above lists and attributes, the Model class in both
    SBML Level 2 and Level 3 has the usual two attributes of 'id' and
    'name', and both are optional.  As is the case for other SBML
    components with 'id' and 'name' attributes, they must be used
    according to the guidelines described in the SBML specifications.
    (Within the frameworks of SBML Level 2 and Level 3, a Model object
    identifier has no assigned meaning, but extension packages planned for
    SBML Level 3 are likely to make use of this identifier.)

    Finally, SBML Level 3 has introduced a number of additional Model
    attributes.  They are discussed in a separate section below.

    Approaches to creating objects using the libSBML API
    ======================================================================

    LibSBML provides two main mechanisms for creating objects: class
    constructors (e.g., Species.Species() ),  and createObject() 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 createObject()
    methods.  These methods both create an object and link it to the
    parent in one step. Here is an example:

      # Create an SBMLDocument object in Level 3 Version 1 format.
      # Make sure to check for possible failures.

      try:
        sbmlDoc = SBMLDocument(3, 1)
      except ValueError:
        print('Could not create SBMLDocument object')
        sys.exit(1)

      # Create a Model object inside the SBMLDocument object and set its
      # identifier, checking the returned values.  The call to setId() returns a
      # status code to indicate whether the assignment was successful.

      model = sbmlDoc.createModel()
      if model == None:
        # Do something to handle the error here.
        print('Unable to create Model object.')
        sys.exit(1)

      status = model.setId('BestModelEver')
      if status != LIBSBML_OPERATION_SUCCESS:
        # Do something to handle the error here.
        print('Unable to set identifier on the Model object')
        sys.exit(1)

      # Create a Species object inside the Model and set its identifier.
      # Again, the setId() returns a status code to indicate whether the
      # assignment was successful.

      sp = model.createSpecies()
      if sp == None:
        # Do something to handle the error here.
        print('Unable to create Species object.')
        sys.exit(1)

      status = sp.setId('BestSpeciesEver')
      if status != LIBSBML_OPERATION_SUCCESS:
        # Do something to handle the error here.
        print('Unable to set identifier on the Species object')
        sys.exit(1)

    The createObject() 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 <listOfObjects>
    elements in the finished XML rendition of SBML.)  In the example
    above, Model.createSpecies() adds the created species directly to the
    <listOfSpeciesgt; list in the model.  Subsequently, methods called on
    the species change the species in the model (which is what is expected
    in most situations).

    Consistency and adherence to SBML specifications
    ======================================================================

    To make it easier for applications to do whatever they need, libSBML
    version 5.18.0

    is relatively lax when it comes to enforcing correctness and
    completeness of models during model construction and editing.
    Essentially, libSBML will 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---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.

    Model attributes introduced in SBML Level 3
    ======================================================================

    As mentioned above, the Model class has a number of optional
    attributes in SBML Level 3.  These are 'substanceUnits', 'timeUnits',
    'volumeUnits', 'areaUnits', 'lengthUnits', 'extentUnits', and
    'conversionFactor.  The following provide more information about them.

    The 'substanceUnits' attribute
    ......................................................................

    The 'substanceUnits' attribute is used to specify the unit of
    measurement associated with substance quantities of Species objects
    that do not specify units explicitly.  If a given Species object
    definition does not specify its unit of substance quantity via the
    'substanceUnits' attribute on the Species object instance, then that
    species inherits the value of the Model 'substanceUnits' attribute.
    If the Model does not define a value for this attribute, then there is
    no unit to inherit, and all species that do not specify individual
    'substanceUnits' attribute values then have no declared units for
    their quantities.  The SBML Level 3 specifications provide more
    details.

    Note that when the identifier of a species appears in a model's
    mathematical expressions, the unit of measurement associated with that
    identifier is not solely determined by setting 'substanceUnits' on
    Model or Species.  Please see the discussion about units given in the
    documentation for the Species class.

    The 'timeUnits' attribute
    ......................................................................

    The 'timeUnits' attribute on SBML Level 3's Model object is used to
    specify the unit in which time is measured in the model.  This
    attribute on Model is the only way to specify a unit for time in a
    model. It is a global attribute; time is measured in the model
    everywhere in the same way.  This is particularly relevant to Reaction
    and RateRule objects in a model: all Reaction and RateRule objects in
    SBML define per-time values, and the unit of time is given by the
    'timeUnits' attribute on the Model object instance.  If the Model
    'timeUnits' attribute has no value, it means that the unit of time is
    not defined for the model's reactions and rate rules.  Leaving it
    unspecified in an SBML model does not result in an invalid model in
    SBML Level 3; however, as a matter of best practice, we strongly
    recommend that all models specify units of measurement for time.

    The 'volumeUnits', 'areaUnits', and 'lengthUnits' attributes
    ......................................................................

    The attributes 'volumeUnits', 'areaUnits' and 'lengthUnits' together
    are used to set the units of measurements for the sizes of Compartment
    objects in an SBML Level 3 model when those objects do not otherwise
    specify units.  The three attributes correspond to the most common
    cases of compartment dimensions: 'volumeUnits' for compartments having
    a 'spatialDimensions' attribute value of ''3',' 'areaUnits' for
    compartments having a 'spatialDimensions' attribute value of ''2','
    and 'lengthUnits' for compartments having a 'spatialDimensions'
    attribute value of ''1'.'  The attributes are not applicable to
    compartments whose 'spatialDimensions' attribute values are not one of
    ''1',' ''2'' or ''3'.'

    If a given Compartment object instance does not provide a value for
    its 'units' attribute, then the unit of measurement of that
    compartment's size is inherited from the value specified by the Model
    'volumeUnits', 'areaUnits' or 'lengthUnits' attribute, as appropriate
    based on the Compartment object's 'spatialDimensions' attribute value.
    If the Model object does not define the relevant attribute, then there
    are no units to inherit, and all Compartment objects that do not set a
    value for their 'units' attribute then have no units associated with
    their compartment sizes.

    The use of three separate attributes is a carry-over from SBML Level
    2.  Note that it is entirely possible for a model to define a value
    for two or more of the attributes 'volumeUnits', 'areaUnits' and
    'lengthUnits' simultaneously, because SBML models may contain
    compartments with different numbers of dimensions.

    The 'extentUnits' attribute
    ......................................................................

    Reactions are processes that occur over time.  These processes involve
    events of some sort, where a single ``reaction event'' is one in which
    some set of entities (known as reactants, products and modifiers in
    SBML) interact, once.  The extent of a reaction is a measure of how
    many times the reaction has occurred, while the time derivative of the
    extent gives the instantaneous rate at which the reaction is
    occurring.  Thus, what is colloquially referred to as the 'rate of the
    reaction' is in fact equal to the rate of change of reaction extent.

    In SBML Level 3, the combination of 'extentUnits' and 'timeUnits'
    defines the units of kinetic laws in SBML and establishes how the
    numerical value of each KineticLaw object's mathematical formula is
    meant to be interpreted in a model.  The units of the kinetic laws are
    taken to be 'extentUnits' divided by 'timeUnits'.

    Note that this embodies an important principle in SBML Level 3 models:
    all reactions in an SBML model must have the same units for the rate
    of change of extent.  In other words, the units of all reaction rates
    in the model must be the same.  There is only one global value for
    'extentUnits' and one global value for 'timeUnits'.

    The 'conversionFactor' attribute
    ......................................................................

    The attribute 'conversionFactor' in SBML Level 3's Model object
    defines a global value inherited by all Species object instances that
    do not define separate values for their 'conversionFactor' attributes.
    The value of this attribute must refer to a Parameter object instance
    defined in the model.  The Parameter object in question must be a
    constant; ie it must have its 'constant' attribute value set to
    ''True'.'

    If a given Species object definition does not specify a conversion
    factor via the 'conversionFactor' attribute on Species, then the
    species inherits the conversion factor specified by the Model
    'conversionFactor' attribute.  If the Model does not define a value
    for this attribute, then there is no conversion factor to inherit.
    More information about conversion factors is provided in the SBML
    Level 3 specifications.

    """

    __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__(Model self, unsigned int level, unsigned int version) -> Model
        __init__(Model self, SBMLNamespaces sbmlns) -> Model
        __init__(Model self, Model orig) -> Model


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            Model(SBMLNamespaces sbmlns)

        Creates a new Model using the given SBMLNamespaces object 'sbmlns'.

        The SBMLNamespaces object encapsulates SBML Level/Version/namespaces
        information.  It is used to communicate the SBML Level, Version, and
        (in Level 3) packages used in addition to SBML Level 3 Core.  A common
        approach to using libSBML's SBMLNamespaces facilities is to create an
        SBMLNamespaces object somewhere in a program once, then hand that
        object as needed to object constructors that accept SBMLNamespaces as
        arguments.

        Parameter 'sbmlns' is an SBMLNamespaces object.

        Throws SBMLConstructorException: Thrown if the given 'sbmlns' is
        inconsistent or incompatible with this object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            Model(long level, long version)

        Creates a new Model using the given SBML 'level' and 'version' values.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        Model.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this Model.

        Throws SBMLConstructorException: Thrown if the given 'level' and
        'version' combination are invalid or if this object is incompatible
        with the given level and version.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            Model(Model orig)

        Copy constructor; creates a (deep) copy of the given Model object.

        Parameter 'orig' is the object to copy.

        """
        this = _libsbml.new_Model(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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


        Creates and returns a deep copy of this Model object.

        Returns the (deep) copy of this Model object.

        """
        return _libsbml.Model_clone(self)


    def getElementBySId(self, id):
        """
        getElementBySId(Model self, string id) -> SBase


        Returns the first child element found that has the given 'id'.

        This operation searches the model-wide SId identifier type namespace

        Parameter 'id' is string representing the id of the object to find.

        Returns pointer to the first element found with the given 'id', or
        'None' if no such object is found.

        """
        return _libsbml.Model_getElementBySId(self, id)


    def getElementByMetaId(self, metaid):
        """
        getElementByMetaId(Model self, string metaid) -> SBase


        Returns the first child element it can find with the given 'metaid'.

        Parameter 'metaid' is string representing the meta-identifier of the
        object to find.

        Returns pointer to the first element found with the given 'metaid', or
        None if no such object is found.

        """
        return _libsbml.Model_getElementByMetaId(self, metaid)


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


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

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is now recommended to use the
        getIdAttribute() function instead.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns the id of this Model.

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.Model_getId(self)


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


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

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns the name of this SBML object, or the empty string if not set
        or unsettable.

        See also getIdAttribute(), isSetName(), setName(), unsetName().

        """
        return _libsbml.Model_getName(self)


    def getSubstanceUnits(self):
        """
        getSubstanceUnits(Model self) -> string


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

        Returns the substanceUnits of this Model.

        Note: The 'substanceUnits' attribute is available in SBML Level 3 but
        is not present on Model in lower Levels of SBML.

        """
        return _libsbml.Model_getSubstanceUnits(self)


    def getTimeUnits(self):
        """
        getTimeUnits(Model self) -> string


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

        Returns the timeUnits of this Model.

        Note: The 'timeUnits' attribute is available in  SBML Level 3 but is
        not present on Model in lower Levels of SBML.

        """
        return _libsbml.Model_getTimeUnits(self)


    def getVolumeUnits(self):
        """
        getVolumeUnits(Model self) -> string


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

        Returns the volumeUnits of this Model.

        Note: The 'volumeUnits' attribute is available in  SBML Level 3 but is
        not present on Model in lower Levels of SBML.

        """
        return _libsbml.Model_getVolumeUnits(self)


    def getAreaUnits(self):
        """
        getAreaUnits(Model self) -> string


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

        Returns the areaUnits of this Model.

        Note: The 'areaUnits' attribute is available in  SBML Level 3 but is
        not present on Model in lower Levels of SBML.

        """
        return _libsbml.Model_getAreaUnits(self)


    def getLengthUnits(self):
        """
        getLengthUnits(Model self) -> string


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

        Returns the lengthUnits of this Model.

        Note: The 'lengthUnits' attribute is available in  SBML Level 3 but is
        not present on Model in lower Levels of SBML.

        """
        return _libsbml.Model_getLengthUnits(self)


    def getExtentUnits(self):
        """
        getExtentUnits(Model self) -> string


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

        Returns the extentUnits of this Model.

        Note: The 'extentUnits' attribute is available in  SBML Level 3 but is
        not present on Model in lower Levels of SBML.

        """
        return _libsbml.Model_getExtentUnits(self)


    def getConversionFactor(self):
        """
        getConversionFactor(Model self) -> string


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

        Returns the conversionFactor of this Model.

        Note: The 'conversionFactor' attribute is available in  SBML Level 3
        but is not present on Model in lower Levels of SBML.

        """
        return _libsbml.Model_getConversionFactor(self)


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


        Predicate returning 'True' if this Model's 'id' attribute is set.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns 'True' if the 'id' attribute of this SBML object is set,
        'False' otherwise.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is recommended that callers use
        isSetIdAttribute() instead.

        See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(),
        isSetIdAttribute().

        """
        return _libsbml.Model_isSetId(self)


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


        Predicate returning 'True' if this Model's 'name' attribute is set.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns 'True' if the 'name' attribute of this SBML object is set,
        'False' otherwise.

        See also getName(), setName(), unsetName().

        """
        return _libsbml.Model_isSetName(self)


    def isSetSubstanceUnits(self):
        """
        isSetSubstanceUnits(Model self) -> bool


        Predicate returning 'True' if this Model's 'substanceUnits' attribute
        is set.

        Returns 'True' if the 'substanceUnits' attribute of this Model is set,
        'False' otherwise.

        Note: The 'substanceUnits' attribute is available in  SBML Level 3 but
        is not present on Model in lower Levels of SBML.

        """
        return _libsbml.Model_isSetSubstanceUnits(self)


    def isSetTimeUnits(self):
        """
        isSetTimeUnits(Model self) -> bool


        Predicate returning 'True' if this Model's 'timeUnits' attribute is
        set.

        Returns 'True' if the 'timeUnits' attribute of this Model is set,
        'False' otherwise.

        Note: The 'substanceUnits' attribute is available in  SBML Level 3 but
        is not present on Model in lower Levels of SBML.

        """
        return _libsbml.Model_isSetTimeUnits(self)


    def isSetVolumeUnits(self):
        """
        isSetVolumeUnits(Model self) -> bool


        Predicate returning 'True' if this Model's 'volumeUnits' attribute is
        set.

        Returns 'True' if the 'volumeUnits' attribute of this Model is set,
        'False' otherwise.

        Note: The 'volumeUnits' attribute is available in  SBML Level 3 but is
        not present on Model in lower Levels of SBML.

        """
        return _libsbml.Model_isSetVolumeUnits(self)


    def isSetAreaUnits(self):
        """
        isSetAreaUnits(Model self) -> bool


        Predicate returning 'True' if this Model's 'areaUnits' attribute is
        set.

        Returns 'True' if the 'areaUnits' attribute of this Model is set,
        'False' otherwise.

        Note: The 'areaUnits' attribute is available in  SBML Level 3 but is
        not present on Model in lower Levels of SBML.

        """
        return _libsbml.Model_isSetAreaUnits(self)


    def isSetLengthUnits(self):
        """
        isSetLengthUnits(Model self) -> bool


        Predicate returning 'True' if this Model's 'lengthUnits' attribute is
        set.

        Returns 'True' if the 'lengthUnits' attribute of this Model is set,
        'False' otherwise.

        Note: The 'lengthUnits' attribute is available in  SBML Level 3 but is
        not present on Model in lower Levels of SBML.

        """
        return _libsbml.Model_isSetLengthUnits(self)


    def isSetExtentUnits(self):
        """
        isSetExtentUnits(Model self) -> bool


        Predicate returning 'True' if this Model's 'extentUnits' attribute is
        set.

        Returns 'True' if the 'extentUnits' attribute of this Model is set,
        'False' otherwise.

        Note: The 'extentUnits' attribute is available in  SBML Level 3 but is
        not present on Model in lower Levels of SBML.

        """
        return _libsbml.Model_isSetExtentUnits(self)


    def isSetConversionFactor(self):
        """
        isSetConversionFactor(Model self) -> bool


        Predicate returning 'True' if this Model's 'conversionFactor'
        attribute is set.

        Returns 'True' if the 'conversionFactor' attribute of this Model is
        set, 'False' otherwise.

        Note: The 'conversionFactor' attribute is available in  SBML Level 3
        but is not present on Model in lower Levels of SBML.

        """
        return _libsbml.Model_isSetConversionFactor(self)


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


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

        The string 'sid' is copied.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Parameter 'sid' is the string to use as the identifier of this object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.Model_setId(self, sid)


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


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

        The string in 'name' is copied.

        Parameter 'name' is the new name for the SBML object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Model_setName(self, name)


    def setSubstanceUnits(self, units):
        """
        setSubstanceUnits(Model self, string units) -> int


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

        The string in 'units' is copied.

        Parameter 'units' is the new substanceUnits for the Model.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        Note: The 'substanceUnits' attribute is available in  SBML Level 3 but
        is not present on Model in lower Levels of SBML.

        """
        return _libsbml.Model_setSubstanceUnits(self, units)


    def setTimeUnits(self, units):
        """
        setTimeUnits(Model self, string units) -> int


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

        The string in 'units' is copied.

        Parameter 'units' is the new timeUnits for the Model.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        Note: The 'timeUnits' attribute is available in  SBML Level 3 but is
        not present on Model in lower Levels of SBML.

        """
        return _libsbml.Model_setTimeUnits(self, units)


    def setVolumeUnits(self, units):
        """
        setVolumeUnits(Model self, string units) -> int


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

        The string in 'units' is copied.

        Parameter 'units' is the new volumeUnits for the Model.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        Note: The 'volumeUnits' attribute is available in  SBML Level 3 but is
        not present on Model in lower Levels of SBML.

        """
        return _libsbml.Model_setVolumeUnits(self, units)


    def setAreaUnits(self, units):
        """
        setAreaUnits(Model self, string units) -> int


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

        The string in 'units' is copied.

        Parameter 'units' is the new areaUnits for the Model.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        Note: The 'areaUnits' attribute is available in  SBML Level 3 but is
        not present on Model in lower Levels of SBML.

        """
        return _libsbml.Model_setAreaUnits(self, units)


    def setLengthUnits(self, units):
        """
        setLengthUnits(Model self, string units) -> int


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

        The string in 'units' is copied.

        Parameter 'units' is the new lengthUnits for the Model.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        Note: The 'lengthUnits' attribute is available in  SBML Level 3 but is
        not present on Model in lower Levels of SBML.

        """
        return _libsbml.Model_setLengthUnits(self, units)


    def setExtentUnits(self, units):
        """
        setExtentUnits(Model self, string units) -> int


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

        The string in 'units' is copied.

        Parameter 'units' is the new extentUnits for the Model.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        Note: The 'extentUnits' attribute is available in  SBML Level 3 but is
        not present on Model in lower Levels of SBML.

        """
        return _libsbml.Model_setExtentUnits(self, units)


    def setConversionFactor(self, units):
        """
        setConversionFactor(Model self, string units) -> int


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

        The string in 'units' is copied.

        Parameter 'units' is the new conversionFactor for the Model.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        Note: The 'conversionFactor' attribute is available in  SBML Level 3
        but is not present on Model in lower Levels of SBML.

        """
        return _libsbml.Model_setConversionFactor(self, units)


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


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

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.Model_unsetId(self)


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


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

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getName(), setName(), isSetName().

        """
        return _libsbml.Model_unsetName(self)


    def unsetSubstanceUnits(self):
        """
        unsetSubstanceUnits(Model self) -> int


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

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        Note: The 'substanceUnits' attribute is available in  SBML Level 3 but
        is not present on Model in lower Levels of SBML.

        """
        return _libsbml.Model_unsetSubstanceUnits(self)


    def unsetTimeUnits(self):
        """
        unsetTimeUnits(Model self) -> int


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

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        Note: The 'timeUnits' attribute is available in  SBML Level 3 but is
        not present on Model in lower Levels of SBML.

        """
        return _libsbml.Model_unsetTimeUnits(self)


    def unsetVolumeUnits(self):
        """
        unsetVolumeUnits(Model self) -> int


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

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        Note: The 'volumeUnits' attribute is available in  SBML Level 3 but is
        not present on Model in lower Levels of SBML.

        """
        return _libsbml.Model_unsetVolumeUnits(self)


    def unsetAreaUnits(self):
        """
        unsetAreaUnits(Model self) -> int


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

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        * LIBSBML_OPERATION_FAILED

        Note: The 'areaUnits' attribute is available in  SBML Level 3 but is
        not present on Model in lower Levels of SBML.

        """
        return _libsbml.Model_unsetAreaUnits(self)


    def unsetLengthUnits(self):
        """
        unsetLengthUnits(Model self) -> int


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

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        * LIBSBML_OPERATION_FAILED

        Note: The 'lengthUnits' attribute is available in  SBML Level 3 but is
        not present on Model in lower Levels of SBML.

        """
        return _libsbml.Model_unsetLengthUnits(self)


    def unsetExtentUnits(self):
        """
        unsetExtentUnits(Model self) -> int


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

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        * LIBSBML_OPERATION_FAILED

        Note: The 'extentUnits' attribute is available in  SBML Level 3 but is
        not present on Model in lower Levels of SBML.

        """
        return _libsbml.Model_unsetExtentUnits(self)


    def unsetConversionFactor(self):
        """
        unsetConversionFactor(Model self) -> int


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

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        * LIBSBML_OPERATION_FAILED

        Note: The 'conversionFactor' attribute is available in  SBML Level 3
        but is not present on Model in lower Levels of SBML.

        """
        return _libsbml.Model_unsetConversionFactor(self)


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


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

        Parameter 'fd' is the FunctionDefinition to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_DUPLICATE_OBJECT_ID

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_OPERATION_FAILED

        Note: This method should be used with some caution.  The fact that
        this method copies the object passed to it means that the caller will
        be left holding a physically different object instance than the one
        contained inside this object.  Changes made to the original object
        instance (such as resetting attribute values) will not affect the
        instance in this object.  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 other methods on this class
        (particularly a corresponding method whose name begins with the word
        create) for alternatives that do not lead to these issues.

        See also createFunctionDefinition().

        """
        return _libsbml.Model_addFunctionDefinition(self, fd)


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


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

        Parameter 'ud' is the UnitDefinition object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_DUPLICATE_OBJECT_ID

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_OPERATION_FAILED

        Note: This method should be used with some caution.  The fact that
        this method copies the object passed to it means that the caller will
        be left holding a physically different object instance than the one
        contained inside this object.  Changes made to the original object
        instance (such as resetting attribute values) will not affect the
        instance in this object.  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 other methods on this class
        (particularly a corresponding method whose name begins with the word
        create) for alternatives that do not lead to these issues.

        See also createUnitDefinition().

        """
        return _libsbml.Model_addUnitDefinition(self, ud)


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


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

        Parameter 'ct' is the CompartmentType object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_DUPLICATE_OBJECT_ID

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_OPERATION_FAILED

        Note: This method should be used with some caution.  The fact that
        this method copies the object passed to it means that the caller will
        be left holding a physically different object instance than the one
        contained inside this object.  Changes made to the original object
        instance (such as resetting attribute values) will not affect the
        instance in this object.  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 other methods on this class
        (particularly a corresponding method whose name begins with the word
        create) for alternatives that do not lead to these issues.

        Note: The CompartmentType object class is only available in SBML Level
        2 Versions 2-4.  It is not available in Level 1 nor Level 3.

        See also createCompartmentType().

        """
        return _libsbml.Model_addCompartmentType(self, ct)


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


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

        Parameter 'st' is the SpeciesType object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_DUPLICATE_OBJECT_ID

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_OPERATION_FAILED

        Note: This method should be used with some caution.  The fact that
        this method copies the object passed to it means that the caller will
        be left holding a physically different object instance than the one
        contained inside this object.  Changes made to the original object
        instance (such as resetting attribute values) will not affect the
        instance in this object.  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 other methods on this class
        (particularly a corresponding method whose name begins with the word
        create) for alternatives that do not lead to these issues.

        Note: The SpeciesType object class is only available in SBML Level 2
        Versions 2-4.  It is not available in Level 1 nor Level 3.

        See also createSpeciesType().

        """
        return _libsbml.Model_addSpeciesType(self, st)


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


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

        Parameter 'c' is the Compartment object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_DUPLICATE_OBJECT_ID

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_OPERATION_FAILED

        Note: This method should be used with some caution.  The fact that
        this method copies the object passed to it means that the caller will
        be left holding a physically different object instance than the one
        contained inside this object.  Changes made to the original object
        instance (such as resetting attribute values) will not affect the
        instance in this object.  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 other methods on this class
        (particularly a corresponding method whose name begins with the word
        create) for alternatives that do not lead to these issues.

        See also createCompartment().

        """
        return _libsbml.Model_addCompartment(self, c)


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


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

        Parameter 's' is the Species object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_DUPLICATE_OBJECT_ID

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_OPERATION_FAILED

        Note: This method should be used with some caution.  The fact that
        this method copies the object passed to it means that the caller will
        be left holding a physically different object instance than the one
        contained inside this object.  Changes made to the original object
        instance (such as resetting attribute values) will not affect the
        instance in this object.  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 other methods on this class
        (particularly a corresponding method whose name begins with the word
        create) for alternatives that do not lead to these issues.

        See also createSpecies().

        """
        return _libsbml.Model_addSpecies(self, s)


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


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

        Parameter 'p' is the Parameter object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_DUPLICATE_OBJECT_ID

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_OPERATION_FAILED

        Note: This method should be used with some caution.  The fact that
        this method copies the object passed to it means that the caller will
        be left holding a physically different object instance than the one
        contained inside this object.  Changes made to the original object
        instance (such as resetting attribute values) will not affect the
        instance in this object.  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 other methods on this class
        (particularly a corresponding method whose name begins with the word
        create) for alternatives that do not lead to these issues.

        See also createParameter().

        """
        return _libsbml.Model_addParameter(self, p)


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


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

        Parameter 'ia' is the InitialAssignment object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_DUPLICATE_OBJECT_ID

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_OPERATION_FAILED

        Note: This method should be used with some caution.  The fact that
        this method copies the object passed to it means that the caller will
        be left holding a physically different object instance than the one
        contained inside this object.  Changes made to the original object
        instance (such as resetting attribute values) will not affect the
        instance in this object.  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 other methods on this class
        (particularly a corresponding method whose name begins with the word
        create) for alternatives that do not lead to these issues.

        See also createInitialAssignment().

        """
        return _libsbml.Model_addInitialAssignment(self, ia)


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


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

        Parameter 'r' is the Rule object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_DUPLICATE_OBJECT_ID

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_OPERATION_FAILED

        Note: This method should be used with some caution.  The fact that
        this method copies the object passed to it means that the caller will
        be left holding a physically different object instance than the one
        contained inside this object.  Changes made to the original object
        instance (such as resetting attribute values) will not affect the
        instance in this object.  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 other methods on this class
        (particularly a corresponding method whose name begins with the word
        create) for alternatives that do not lead to these issues.

        See also createAlgebraicRule(), createAssignmentRule(),
        createRateRule().

        """
        return _libsbml.Model_addRule(self, r)


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


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

        Parameter 'c' is the Constraint object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_OPERATION_FAILED

        Note: This method should be used with some caution.  The fact that
        this method copies the object passed to it means that the caller will
        be left holding a physically different object instance than the one
        contained inside this object.  Changes made to the original object
        instance (such as resetting attribute values) will not affect the
        instance in this object.  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 other methods on this class
        (particularly a corresponding method whose name begins with the word
        create) for alternatives that do not lead to these issues.

        See also createConstraint().

        """
        return _libsbml.Model_addConstraint(self, c)


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


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

        Parameter 'r' is the Reaction object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_DUPLICATE_OBJECT_ID

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_OPERATION_FAILED

        Note: This method should be used with some caution.  The fact that
        this method copies the object passed to it means that the caller will
        be left holding a physically different object instance than the one
        contained inside this object.  Changes made to the original object
        instance (such as resetting attribute values) will not affect the
        instance in this object.  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 other methods on this class
        (particularly a corresponding method whose name begins with the word
        create) for alternatives that do not lead to these issues.

        See also createReaction().

        """
        return _libsbml.Model_addReaction(self, r)


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


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

        Parameter 'e' is the Event object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_DUPLICATE_OBJECT_ID

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_OPERATION_FAILED

        Note: This method should be used with some caution.  The fact that
        this method copies the object passed to it means that the caller will
        be left holding a physically different object instance than the one
        contained inside this object.  Changes made to the original object
        instance (such as resetting attribute values) will not affect the
        instance in this object.  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 other methods on this class
        (particularly a corresponding method whose name begins with the word
        create) for alternatives that do not lead to these issues.

        See also createEvent().

        """
        return _libsbml.Model_addEvent(self, e)


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


        Creates a new FunctionDefinition inside this Model and returns it.

        The SBML Level and Version of the enclosing Model object, as well as
        any SBML package namespaces, are used to initialize this object's
        corresponding attributes.

        Returns the FunctionDefinition object created.

        See also addFunctionDefinition().

        """
        return _libsbml.Model_createFunctionDefinition(self)


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


        Creates a new UnitDefinition inside this Model and returns it.

        The SBML Level and Version of the enclosing Model object, as well as
        any SBML package namespaces, are used to initialize this object's
        corresponding attributes.

        Returns the UnitDefinition object created.

        See also addUnitDefinition().

        """
        return _libsbml.Model_createUnitDefinition(self)


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


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

        The SBML Level and Version of the enclosing Model object, as well as
        any SBML package namespaces, are used to initialize this object's
        corresponding attributes.

        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 not created and 'None' is returned instead.

        Returns the Unit object created.

        See also addUnitDefinition().

        """
        return _libsbml.Model_createUnit(self)


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


        Creates a new CompartmentType inside this Model and returns it.

        The SBML Level and Version of the enclosing Model object, as well as
        any SBML package namespaces, are used to initialize this object's
        corresponding attributes.

        Returns the CompartmentType object created.

        Note: The CompartmentType object class is only available in SBML Level
        2 Versions 2-4.  It is not available in Level 1 nor Level 3.

        See also addCompartmentType().

        """
        return _libsbml.Model_createCompartmentType(self)


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


        Creates a new SpeciesType inside this Model and returns it.

        The SBML Level and Version of the enclosing Model object, as well as
        any SBML package namespaces, are used to initialize this object's
        corresponding attributes.

        Returns the SpeciesType object created.

        Note: The SpeciesType object class is only available in SBML Level 2
        Versions 2-4.  It is not available in Level 1 nor Level 3.

        See also addSpeciesType().

        """
        return _libsbml.Model_createSpeciesType(self)


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


        Creates a new Compartment inside this Model and returns it.

        The SBML Level and Version of the enclosing Model object, as well as
        any SBML package namespaces, are used to initialize this object's
        corresponding attributes.

        Returns the Compartment object created.

        See also addCompartment().

        """
        return _libsbml.Model_createCompartment(self)


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


        Creates a new Species inside this Model and returns it.

        The SBML Level and Version of the enclosing Model object, as well as
        any SBML package namespaces, are used to initialize this object's
        corresponding attributes.

        Returns the Species object created.

        See also addSpecies().

        """
        return _libsbml.Model_createSpecies(self)


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


        Creates a new Parameter inside this Model and returns it.

        The SBML Level and Version of the enclosing Model object, as well as
        any SBML package namespaces, are used to initialize this object's
        corresponding attributes.

        Returns the Parameter object created.

        See also addParameter().

        """
        return _libsbml.Model_createParameter(self)


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


        Creates a new InitialAssignment inside this Model and returns it.

        The SBML Level and Version of the enclosing Model object, as well as
        any SBML package namespaces, are used to initialize this object's
        corresponding attributes.

        Returns the InitialAssignment object created.

        See also addInitialAssignment().

        """
        return _libsbml.Model_createInitialAssignment(self)


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


        Creates a new AlgebraicRule inside this Model and returns it.

        The SBML Level and Version of the enclosing Model object, as well as
        any SBML package namespaces, are used to initialize this object's
        corresponding attributes.

        Returns the AlgebraicRule object created.

        See also addRule().

        """
        return _libsbml.Model_createAlgebraicRule(self)


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


        Creates a new AssignmentRule inside this Model and returns it.

        The SBML Level and Version of the enclosing Model object, as well as
        any SBML package namespaces, are used to initialize this object's
        corresponding attributes.

        Returns the AssignmentRule object created.

        See also addRule().

        """
        return _libsbml.Model_createAssignmentRule(self)


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


        Creates a new RateRule inside this Model and returns it.

        The SBML Level and Version of the enclosing Model object, as well as
        any SBML package namespaces, are used to initialize this object's
        corresponding attributes.

        Returns the RateRule object created.

        See also addRule().

        """
        return _libsbml.Model_createRateRule(self)


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


        Creates a new Constraint inside this Model and returns it.

        The SBML Level and Version of the enclosing Model object, as well as
        any SBML package namespaces, are used to initialize this object's
        corresponding attributes.

        Returns the Constraint object created.

        See also addConstraint().

        """
        return _libsbml.Model_createConstraint(self)


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


        Creates a new Reaction inside this Model and returns it.

        The SBML Level and Version of the enclosing Model object, as well as
        any SBML package namespaces, are used to initialize this object's
        corresponding attributes.

        Returns the Reaction object created.

        See also addReaction().

        """
        return _libsbml.Model_createReaction(self)


    def createReactant(self):
        """
        createReactant(Model 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 SBML Level and Version of the enclosing Model object, as well as
        any SBML package namespaces, are used to initialize this object's
        corresponding attributes.

        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 not created
        and 'None' is returned instead.

        Returns the SpeciesReference object created.  If a Reaction does not
        exist for this model, a new SpeciesReference is not created and 'None'
        is returned.

        """
        return _libsbml.Model_createReactant(self)


    def createProduct(self):
        """
        createProduct(Model 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 SBML Level and Version of the enclosing Model object, as well as
        any SBML package namespaces, are used to initialize this object's
        corresponding attributes.

        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 not created
        and 'None' is returned instead.

        Returns the SpeciesReference object created. If a Reaction does not
        exist for this model, a new SpeciesReference is not created and 'None'
        is returned.

        """
        return _libsbml.Model_createProduct(self)


    def createModifier(self):
        """
        createModifier(Model 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 SBML Level and Version of the enclosing Model object, as well as
        any SBML package namespaces, are used to initialize this object's
        corresponding attributes.

        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 not created
        and 'None' is returned instead.

        Returns the SpeciesReference object created.  If a Reaction does not
        exist for this model, a new SpeciesReference is not created and 'None'
        is returned.

        """
        return _libsbml.Model_createModifier(self)


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


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

        The SBML Level and Version of the enclosing Model object, as well as
        any SBML package namespaces, are used to initialize this object's
        corresponding attributes.

        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 not created
        and 'None' is returned instead.

        Returns the KineticLaw object created.  If a Reaction does not exist
        for this model, or a Reaction does exist but already has a KineticLaw,
        a new KineticLaw is not created and 'None' is returned.

        """
        return _libsbml.Model_createKineticLaw(self)


    def createKineticLawParameter(self):
        """
        createKineticLawParameter(Model 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 SBML Level and Version of the enclosing Model object, as well as
        any SBML package namespaces, are used to initialize this object's
        corresponding attributes.

        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
        not created and 'None' is returned instead.

        Returns the Parameter object created.  If a Reaction does not exist
        for this model, or a KineticLaw for the Reaction does not exist, a new
        Parameter is not created and 'None' is returned.

        """
        return _libsbml.Model_createKineticLawParameter(self)


    def createKineticLawLocalParameter(self):
        """
        createKineticLawLocalParameter(Model self) -> LocalParameter


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

        The SBML Level and Version of the enclosing Model object, as well as
        any SBML package namespaces, are used to initialize this object's
        corresponding attributes.

        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
        not created and 'None' is returned instead.

        Returns the Parameter object created.  If a Reaction does not exist
        for this model, or a KineticLaw for the Reaction does not exist, a new
        Parameter is not created and 'None' is returned.

        """
        return _libsbml.Model_createKineticLawLocalParameter(self)


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


        Creates a new Event inside this Model and returns it.

        The SBML Level and Version of the enclosing Model object, as well as
        any SBML package namespaces, are used to initialize this object's
        corresponding attributes.

        Returns the Event object created.

        """
        return _libsbml.Model_createEvent(self)


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


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

        The SBML Level and Version of the enclosing Model object, as well as
        any SBML package namespaces, are used to initialize this object's
        corresponding attributes.

        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 not created and
        'None' is returned instead.

        Returns the EventAssignment object created.

        """
        return _libsbml.Model_createEventAssignment(self)


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


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

        The SBML Level and Version of the enclosing Model object, as well as
        any SBML package namespaces, are used to initialize this object's
        corresponding attributes.

        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 not created and
        'None' is returned instead.

        Returns the Trigger object created.

        """
        return _libsbml.Model_createTrigger(self)


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


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

        The SBML Level and Version of the enclosing Model object, as well as
        any SBML package namespaces, are used to initialize this object's
        corresponding attributes.

        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 not created and
        'None' is returned instead.

        Returns the Delay object created.

        """
        return _libsbml.Model_createDelay(self)


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            setAnnotation(XMLNode annotation)

        Sets the value of the 'annotation' subelement of this SBML object to a
        copy of '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 '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().

        Parameter 'annotation' is an XML structure that is to be used as the
        content of the 'annotation' subelement of this object.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        See also appendAnnotation().

        ______________________________________________________________________
        Method variant with the following signature:

            setAnnotation(string annotation)

        Sets the value of the 'annotation' subelement of this SBML object to a
        copy of '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 '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().

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

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also appendAnnotation().

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


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            appendAnnotation(XMLNode annotation)

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

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

        Parameter 'annotation' is an XML structure that is to be copied and
        appended to the content of the 'annotation' subelement of this object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also setAnnotation().

        ______________________________________________________________________
        Method variant with the following signature:

            appendAnnotation(string annotation)

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

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

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

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also setAnnotation().

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


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


        Get the ListOfFunctionDefinitions object in this Model.

        Returns the list of FunctionDefinitions for this Model.

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


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


        Get the ListOfUnitDefinitions object in this Model.

        Returns the list of UnitDefinitions for this Model.

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


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


        Get the ListOfCompartmentTypes object in this Model.

        Returns the list of CompartmentTypes for this Model.

        Note: The CompartmentType object class is only available in SBML Level
        2 Versions 2-4.  It is not available in Level 1 nor Level 3.

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


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


        Get the ListOfSpeciesTypes object in this Model.

        Returns the list of SpeciesTypes for this Model.

        Note: The SpeciesType object class is only available in SBML Level 2
        Versions 2-4.  It is not available in Level 1 nor Level 3.

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


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


        Get the ListOfCompartments object in this Model.

        Returns the list of Compartments for this Model.

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


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


        Get the ListOfSpecies object in this Model.

        Returns the list of Species for this Model.

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


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


        Get the ListOfParameters object in this Model.

        Returns the list of Parameters for this Model.

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


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


        Get the ListOfInitialAssignments object in this Model.

        Returns the list of InitialAssignments for this Model.

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


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


        Get the ListOfRules object in this Model.

        Returns the list of Rules for this Model.

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


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


        Get the ListOfConstraints object in this Model.

        Returns the list of Constraints for this Model.

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


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


        Get the ListOfReactions object in this Model.

        Returns the list of Reactions for this Model.

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


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


        Get the ListOfEvents object in this Model.

        Returns the list of Events for this Model.

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


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getFunctionDefinition(long n)

        Get the nth FunctionDefinitions object in this Model.

        Parameter 'n' is the index of the object to return.

        Returns the nth FunctionDefinition of this Model. If the index 'n' is
        invalid, 'None' is returned.

        ______________________________________________________________________
        Method variant with the following signature:

            getFunctionDefinition(string sid)

        Get a FunctionDefinition object based on its identifier.

        Parameter 'sid' is the identifier to search for.

        Returns the FunctionDefinition in this Model with the identifier 'sid'
        or 'None' if no such FunctionDefinition exists.

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


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getUnitDefinition(long n)

        Get the nth UnitDefinition object in this Model.

        Parameter 'n' is the index of the object to return.

        Returns the nth UnitDefinition of this Model. If the index 'n' is
        invalid, 'None' is returned.

        ______________________________________________________________________
        Method variant with the following signature:

            getUnitDefinition(string sid)

        Get a UnitDefinition based on its identifier.

        Parameter 'sid' is the identifier to search for.

        Returns the UnitDefinition in this Model with the identifier 'sid' or
        'None' if no such UnitDefinition exists.

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


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getCompartmentType(long n)

        Get the nth CompartmentType object in this Model.

        Parameter 'n' is the index of the object to return.

        Returns the nth CompartmentType of this Model. If the index 'n' is
        invalid, 'None' is returned.

        Note: The CompartmentType object class is only available in SBML Level
        2 Versions 2-4.  It is not available in Level 1 nor Level 3.

        ______________________________________________________________________
        Method variant with the following signature:

            getCompartmentType(string sid)

        Get a CompartmentType object based on its identifier.

        Parameter 'sid' is the identifier to search for.

        Returns the CompartmentType in this Model with the identifier 'sid' or
        'None' if no such CompartmentType exists.

        Note: The CompartmentType object class is only available in SBML Level
        2 Versions 2-4.  It is not available in Level 1 nor Level 3.

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


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getSpeciesType(long n)

        Get the nth SpeciesType object in this Model.

        Parameter 'n' is the index of the object to return.

        Returns the nth SpeciesType of this Model. If the index 'n' is
        invalid, 'None' is returned.

        Note: The SpeciesType object class is only available in SBML Level 2
        Versions 2-4.  It is not available in Level 1 nor Level 3.

        ______________________________________________________________________
        Method variant with the following signature:

            getSpeciesType(string sid)

        Get a SpeciesType object based on its identifier.

        Parameter 'sid' is the identifier to search for.

        Returns the SpeciesType in this Model with the identifier 'sid' or
        'None' if no such SpeciesType exists.

        Note: The SpeciesType object class is only available in SBML Level 2
        Versions 2-4.  It is not available in Level 1 nor Level 3.

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


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getCompartment(long n)

        Get the nth Compartment object in this Model.

        Parameter 'n' is the index of the object to return.

        Returns the nth Compartment of this Model. If the index 'n' is
        invalid, 'None' is returned.

        ______________________________________________________________________
        Method variant with the following signature:

            getCompartment(string sid)

        Get a Compartment object based on its identifier.

        Parameter 'sid' is the identifier to search for.

        Returns the Compartment in this Model with the identifier 'sid' or
        'None' if no such Compartment exists.

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


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getSpecies(long n)

        Get the nth Species object in this Model.

        Parameter 'n' is the index of the object to return.

        Returns the nth Species of this Model. If the index 'n' is invalid,
        'None' is returned.

        ______________________________________________________________________
        Method variant with the following signature:

            getSpecies(string sid)

        Get a Species object based on its identifier.

        Parameter 'sid' is the identifier to search for.

        Returns the Species in this Model with the identifier 'sid' or 'None'
        if no such Species exists.

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


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getParameter(long n)

        Get the nth Parameter object in this Model.

        Parameter 'n' is the index of the object to return.

        Returns the nth Parameter of this Model. If the index 'n' is invalid,
        'None' is returned.

        ______________________________________________________________________
        Method variant with the following signature:

            getParameter(string sid)

        Get a Parameter object based on its identifier.

        Parameter 'sid' is the identifier to search for.

        Returns the Parameter in this Model with the identifier 'sid' or
        'None' if no such Parameter exists.

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


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getInitialAssignment(string symbol)

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

        Parameter 'symbol' is the symbol to search for.

        Returns the InitialAssignment in this Model with the given 'symbol'
        attribute value or 'None' if no such InitialAssignment exists.

        ______________________________________________________________________
        Method variant with the following signature:

            getInitialAssignment(long n)

        Get the nth InitialAssignment object in this Model.

        Parameter 'n' is the index of the object to return.

        Returns the nth InitialAssignment of this Model. If the index 'n' is
        invalid, 'None' is returned.

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


    def getInitialAssignmentBySymbol(self, *args):
        """
        getInitialAssignmentBySymbol(Model self, string symbol) -> InitialAssignment
        getInitialAssignmentBySymbol(Model self, string symbol) -> InitialAssignment


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

        Parameter 'symbol' is the symbol to search for.

        Returns the InitialAssignment in this Model with the given 'symbol'
        attribute value or 'None' if no such InitialAssignment exists.

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


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getRule(string variable)

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

        Parameter 'variable' is the variable to search for.

        Returns the Rule in this Model with the given 'variable' attribute
        value or 'None' if no such Rule exists.

        ______________________________________________________________________
        Method variant with the following signature:

            getRule(long n)

        Get the nth Rule object in this Model.

        Parameter 'n' is the index of the object to return.

        Returns the nth Rule of this Model. If the index 'n' is invalid,
        'None' is returned.

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


    def getRuleByVariable(self, *args):
        """
        getRuleByVariable(Model self, string variable) -> Rule
        getRuleByVariable(Model self, string variable) -> Rule


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

        Parameter 'variable' is the variable to search for.

        Returns the Rule in this Model with the given 'variable' attribute
        value or 'None' if no such Rule exists.

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


    def getAssignmentRule(self, *args):
        """
        getAssignmentRule(Model self, string variable) -> AssignmentRule
        getAssignmentRule(Model self, string variable) -> AssignmentRule


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

        Parameter 'variable' is the variable to search for.

        Returns the Rule in this Model with the given 'variable' attribute
        value or 'None' if no such Rule exists.

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


    def getRateRule(self, *args):
        """
        getRateRule(Model self, string variable) -> RateRule
        getRateRule(Model self, string variable) -> RateRule


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

        Parameter 'variable' is the symbol to search for.

        Returns the Rule in this Model with the given 'variable' attribute
        value or 'None' if no such Rule exists.

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


    def getAssignmentRuleByVariable(self, *args):
        """
        getAssignmentRuleByVariable(Model self, string variable) -> AssignmentRule
        getAssignmentRuleByVariable(Model self, string variable) -> AssignmentRule


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

        Parameter 'variable' is the variable to search for.

        Returns the Rule in this Model with the given 'variable' attribute
        value or 'None' if no such Rule exists.

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


    def getRateRuleByVariable(self, *args):
        """
        getRateRuleByVariable(Model self, string variable) -> RateRule
        getRateRuleByVariable(Model self, string variable) -> RateRule


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

        Parameter 'variable' is the variable to search for.

        Returns the Rule in this Model with the given 'variable' attribute
        value or 'None' if no such Rule exists.

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


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


        Get the nth Constraint object in this Model.

        Parameter 'n' is the index of the object to return.

        Returns the nth Constraint of this Model. If the index 'n' is invalid,
        'None' is returned.

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


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getReaction(long n)

        Get the nth Reaction object in this Model.

        Parameter 'n' is the index of the object to return.

        Returns the nth Reaction of this Model. If the index 'n' is invalid,
        'None' is returned.

        ______________________________________________________________________
        Method variant with the following signature:

            getReaction(string sid)

        Get a Reaction object based on its identifier.

        Parameter 'sid' is the identifier to search for.

        Returns the Reaction in this Model with the identifier 'sid' or 'None'
        if no such Reaction exists.

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


    def getSpeciesReference(self, *args):
        """
        getSpeciesReference(Model self, string sid) -> SpeciesReference
        getSpeciesReference(Model self, string sid) -> SpeciesReference


        Get a SpeciesReference object based on its identifier.

        Parameter 'sid' is the identifier to search for.

        Returns the SpeciesReference in this Model with the identifier 'sid'
        or 'None' if no such SpeciesReference exists.

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


    def getModifierSpeciesReference(self, *args):
        """
        getModifierSpeciesReference(Model self, string sid) -> ModifierSpeciesReference
        getModifierSpeciesReference(Model self, string sid) -> ModifierSpeciesReference


        Get a ModifierSpeciesReference object based on its identifier.

        Parameter 'sid' is the identifier to search for.

        Returns the ModifierSpeciesReference in this Model with the
        identifier 'sid' or 'None' if no such ModifierSpeciesReference exists.

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


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getEvent(long n)

        Get the nth Event object in this Model.

        Parameter 'n' is the index of the object to return.

        Returns the nth Event of this Model. If the index 'n' is invalid,
        'None' is returned.

        ______________________________________________________________________
        Method variant with the following signature:

            getEvent(string sid)

        Get an Event object based on its identifier.

        Parameter 'sid' is the identifier to search for.

        Returns the Event in this Model with the identifier 'sid' or 'None' if
        no such Event exists.

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


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


        Get the number of FunctionDefinition objects in this Model.

        Returns the number of FunctionDefinitions in this Model.

        """
        return _libsbml.Model_getNumFunctionDefinitions(self)


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


        Get the number of UnitDefinition objects in this Model.

        Returns the number of UnitDefinitions in this Model.

        """
        return _libsbml.Model_getNumUnitDefinitions(self)


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


        Get the number of CompartmentType objects in this Model.

        Returns the number of CompartmentTypes in this Model.

        Note: The CompartmentType object class is only available in SBML Level
        2 Versions 2-4.  It is not available in Level 1 nor Level 3.

        """
        return _libsbml.Model_getNumCompartmentTypes(self)


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


        Get the number of SpeciesType objects in this Model.

        Returns the number of SpeciesTypes in this Model.

        Note: The SpeciesType object class is only available in SBML Level 2
        Versions 2-4.  It is not available in Level 1 nor Level 3.

        """
        return _libsbml.Model_getNumSpeciesTypes(self)


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


        Get the number of Compartment objects in this Model.

        Returns the number of Compartments in this Model.

        """
        return _libsbml.Model_getNumCompartments(self)


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


        Get the number of Species objects in this Model.

        Returns the number of Species in this Model.

        """
        return _libsbml.Model_getNumSpecies(self)


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


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

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

        """
        return _libsbml.Model_getNumSpeciesWithBoundaryCondition(self)


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


        Get the number of Parameter objects in this Model.

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

        """
        return _libsbml.Model_getNumParameters(self)


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


        Get the number of InitialAssignment objects in this Model.

        Returns the number of InitialAssignments in this Model.

        """
        return _libsbml.Model_getNumInitialAssignments(self)


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


        Get the number of Rule objects in this Model.

        Returns the number of Rules in this Model.

        """
        return _libsbml.Model_getNumRules(self)


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


        Get the number of Constraint objects in this Model.

        Returns the number of Constraints in this Model.

        """
        return _libsbml.Model_getNumConstraints(self)


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


        Get the number of Reaction objects in this Model.

        Returns the number of Reactions in this Model.

        """
        return _libsbml.Model_getNumReactions(self)


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


        Get the number of Event objects in this Model.

        Returns the number of Events in this Model.

        """
        return _libsbml.Model_getNumEvents(self)


    def removeFromParentAndDelete(self):
        """
        removeFromParentAndDelete(Model self) -> int


        Remove this Model from its parent SBMLDocument object.

        This works by finding this Model's parent SBMLDocument and then
        calling setModel(None) on it, indirectly deleting itself. Overridden
        from the SBase function since the parent is not a ListOf.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Model_removeFromParentAndDelete(self)


    def renameAllIds(self, idTransformer, filter=None):
        """
        renameAllIds(Model self, IdentifierTransformer idTransformer, ElementFilter filter=None) -> int
        renameAllIds(Model self, IdentifierTransformer idTransformer) -> int


        Internal implementation method.

        """
        return _libsbml.Model_renameAllIds(self, idTransformer, filter)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(Model self, string oldid, string newid)


        Replaces all uses of a given 'SIdRef' type attribute value with
        another value.

        In SBML, object identifiers are of a data type called SId. In SBML
        Level 3, an explicit data type called SIdRef was introduced for
        attribute values that refer to SId values; in previous Levels of SBML,
        this data type did not exist and attributes were simply described to
        as 'referring to an identifier', but the effective data type was the
        same as SIdRef in Level 3.  These and other methods of libSBML refer
        to the type SIdRef for all Levels of SBML, even if the corresponding
        SBML specification did not explicitly name the data type.

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas in MathML content, comparing the referenced
        identifiers to the value of 'oldid'.  If any matches are found, the
        matching values are replaced with 'newid'.  The method does not
        descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.Model_renameSIdRefs(self, oldid, newid)


    def renameUnitSIdRefs(self, oldid, newid):
        """
        renameUnitSIdRefs(Model self, string oldid, string newid)


        Replaces all uses of a given 'UnitSIdRef' type attribute value with
        another value.

        In SBML, unit definitions have identifiers of type UnitSId.  In SBML
        Level 3, an explicit data type called UnitSIdRef was introduced for
        attribute values that refer to UnitSId values; in previous Levels of
        SBML, this data type did not exist and attributes were simply
        described to as 'referring to a unit identifier', but the effective
        data type was the same as UnitSIdRef in Level 3.  These and other
        methods of libSBML refer to the type UnitSIdRef for all Levels of
        SBML, even if the corresponding SBML specification did not explicitly
        name the data type.

        This method works by looking at all unit identifier attribute values
        (including, if appropriate, inside mathematical formulas), comparing
        the referenced unit identifiers to the value of 'oldid'.  If any
        matches are found, the matching values are replaced with 'newid'.  The
        method does not descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.Model_renameUnitSIdRefs(self, oldid, newid)


    def convertL1ToL2(self):
        """
        convertL1ToL2(Model self)


        Internal implementation method.

        """
        return _libsbml.Model_convertL1ToL2(self)


    def convertL1ToL3(self, addDefaultUnits=True):
        """
        convertL1ToL3(Model self, bool addDefaultUnits=True)
        convertL1ToL3(Model self)


        Internal implementation method.

        """
        return _libsbml.Model_convertL1ToL3(self, addDefaultUnits)


    def convertL2ToL3(self, strict=False, addDefaultUnits=True):
        """
        convertL2ToL3(Model self, bool strict=False, bool addDefaultUnits=True)
        convertL2ToL3(Model self, bool strict=False)
        convertL2ToL3(Model self)


        Internal implementation method.

        """
        return _libsbml.Model_convertL2ToL3(self, strict, addDefaultUnits)


    def convertL2ToL1(self, strict=False):
        """
        convertL2ToL1(Model self, bool strict=False)
        convertL2ToL1(Model self)


        Internal implementation method.

        """
        return _libsbml.Model_convertL2ToL1(self, strict)


    def convertL3ToL1(self, strict=False):
        """
        convertL3ToL1(Model self, bool strict=False)
        convertL3ToL1(Model self)


        Internal implementation method.

        """
        return _libsbml.Model_convertL3ToL1(self, strict)


    def convertL3ToL2(self, strict=False):
        """
        convertL3ToL2(Model self, bool strict=False)
        convertL3ToL2(Model self)


        Internal implementation method.

        """
        return _libsbml.Model_convertL3ToL2(self, strict)


    def convertFromL3V2(self, strict=False):
        """
        convertFromL3V2(Model self, bool strict=False)
        convertFromL3V2(Model self)


        Internal implementation method.

        """
        return _libsbml.Model_convertFromL3V2(self, strict)


    def dealWithFast(self):
        """
        dealWithFast(Model self)


        Internal implementation method.

        """
        return _libsbml.Model_dealWithFast(self)


    def dealWithL3Fast(self, targetVersion):
        """
        dealWithL3Fast(Model self, unsigned int targetVersion)


        Internal implementation method.

        """
        return _libsbml.Model_dealWithL3Fast(self, targetVersion)


    def addModifiers(self):
        """
        addModifiers(Model self)


        Internal implementation method.

        """
        return _libsbml.Model_addModifiers(self)


    def addConstantAttribute(self):
        """
        addConstantAttribute(Model self)


        Internal implementation method.

        """
        return _libsbml.Model_addConstantAttribute(self)


    def setSpatialDimensions(self, dims=3.0):
        """
        setSpatialDimensions(Model self, double dims=3.0)
        setSpatialDimensions(Model self)


        Internal implementation method.

        """
        return _libsbml.Model_setSpatialDimensions(self, dims)


    def addDefinitionsForDefaultUnits(self):
        """
        addDefinitionsForDefaultUnits(Model self)


        Internal implementation method.

        """
        return _libsbml.Model_addDefinitionsForDefaultUnits(self)


    def dealWithDefaultValues(self):
        """
        dealWithDefaultValues(Model self)


        Internal implementation method.

        """
        return _libsbml.Model_dealWithDefaultValues(self)


    def convertParametersToLocals(self, level, version):
        """
        convertParametersToLocals(Model self, unsigned int level, unsigned int version)


        Internal implementation method.

        """
        return _libsbml.Model_convertParametersToLocals(self, level, version)


    def setSpeciesReferenceConstantValueAndStoichiometry(self):
        """
        setSpeciesReferenceConstantValueAndStoichiometry(Model self)


        Internal implementation method.

        """
        return _libsbml.Model_setSpeciesReferenceConstantValueAndStoichiometry(self)


    def removeParameterRuleUnits(self, strict):
        """
        removeParameterRuleUnits(Model self, bool strict)


        Internal implementation method.

        """
        return _libsbml.Model_removeParameterRuleUnits(self, strict)


    def convertStoichiometryMath(self):
        """
        convertStoichiometryMath(Model self)


        Internal implementation method.

        """
        return _libsbml.Model_convertStoichiometryMath(self)


    def assignRequiredValues(self):
        """
        assignRequiredValues(Model self)


        Internal implementation method.

        """
        return _libsbml.Model_assignRequiredValues(self)


    def dealWithModelUnits(self, strict=False):
        """
        dealWithModelUnits(Model self, bool strict=False)
        dealWithModelUnits(Model self)


        Internal implementation method.

        """
        return _libsbml.Model_dealWithModelUnits(self, strict)


    def dealWithStoichiometry(self):
        """
        dealWithStoichiometry(Model self)


        Internal implementation method.

        """
        return _libsbml.Model_dealWithStoichiometry(self)


    def dealWithEvents(self, strict):
        """
        dealWithEvents(Model self, bool strict)


        Internal implementation method.

        """
        return _libsbml.Model_dealWithEvents(self, strict)


    def removeSpeciesTypes(self):
        """
        removeSpeciesTypes(Model self)


        Internal implementation method.

        """
        return _libsbml.Model_removeSpeciesTypes(self)


    def removeCompartmentTypes(self):
        """
        removeCompartmentTypes(Model self)


        Internal implementation method.

        """
        return _libsbml.Model_removeCompartmentTypes(self)


    def connectToChild(self):
        """connectToChild(Model self)"""
        return _libsbml.Model_connectToChild(self)


    def getTypeCode(self):
        """
        getTypeCode(Model self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_MODEL (default).

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.Model_getTypeCode(self)


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


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

        Returns the name of this element, i.e., ''model'.'

        """
        return _libsbml.Model_getElementName(self)


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


        Populates the internal list of derived units for this Model object.

        This method tells libSBML to (re)calculate all units for all
        components of the enclosing Model object.  The result is stored in an
        internal list of unit data.  Users can access the resulting data by
        calling the method SBase.getDerivedUnitDefinition() available on most
        objects.  (The name 'formula units data' is drawn from the name of the
        internal objects libSBML uses to store the data; note that these
        internal objects are not exposed to callers, because callers can
        interact with the results using the ordinary SBML unit objects.)

        This method is used by libSBML itself in the validator concerned with
        unit consistency.  The unit consistency validator (like all other
        validators in libSBML) is invoked by using
        SBMLDocument.checkConsistency(), with the consistency checks for the
        category LIBSBML_CAT_UNITS_CONSISTENCY turned on.  The method
        populateListFormulaUnitsData() does not need to be called prior to
        invoking the validator if unit consistency checking has not been
        turned off.  This method is only provided for cases when callers have
        a special need to force the unit data to be recalculated.  For
        instance, during construction of a model, a caller may want to
        interrogate libSBML's inferred units without invoking full-blown model
        validation; this is a scenario in which calling
        populateListFormulaUnitsData() may be useful.

        WARNING:

        Computing and inferring units is a time-consuming operation. Callers
        may want to call isPopulatedListFormulaUnitsData() to determine
        whether the units may already have been computed, to save themselves
        the need of invoking unit inference unnecessarily.

        See also isPopulatedListFormulaUnitsData().

        """
        return _libsbml.Model_populateListFormulaUnitsData(self)


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


        Predicate returning 'True' if libSBML has derived units for the
        components of this model.

        LibSBML can infer the units of measurement associated with different
        elements of a model.  When libSBML does that, it builds a complex
        internal structure during a resource-intensive operation.  This is
        done automatically only when callers invoke validation (via
        SBMLDocument.checkConsistency()) and have not turned off the unit
        validation option.

        Callers can force units to be recalculated by calling
        populateListFormulaUnitsData().  To avoid calling that method
        unnecessarily, calling programs may first want to invoke this method
        (isPopulatedListFormulaUnitsData()) to determine whether it is even
        necessary.

        Returns 'True' if the units have already been computed, 'False'
        otherwise.

        """
        return _libsbml.Model_isPopulatedListFormulaUnitsData(self)


    def getFormulaUnitsDataForVariable(self, sid):
        """
        getFormulaUnitsDataForVariable(Model self, string sid) -> FormulaUnitsData *


        Internal implementation method.

        """
        return _libsbml.Model_getFormulaUnitsDataForVariable(self, sid)


    def getFormulaUnitsDataForAssignment(self, sid):
        """
        getFormulaUnitsDataForAssignment(Model self, string sid) -> FormulaUnitsData *


        Internal implementation method.

        """
        return _libsbml.Model_getFormulaUnitsDataForAssignment(self, sid)


    def populateAllElementIdList(self):
        """
        populateAllElementIdList(Model self)


        Populates the internal list of the identifiers of all elements within
        this Model object.

        This method tells libSBML to retrieve the identifiers of all elements
        of the enclosing Model object.  The result is stored in an internal
        list of ids.  Users can access the resulting data by calling the
        method getAllElementIdList().

        WARNING:

        Retrieving all elements within a model is a time-consuming operation.
        Callers may want to call isPopulatedAllElementIdList() to determine
        whether the id list may already have been populated.

        See also isPopulatedAllElementIdList().

        """
        return _libsbml.Model_populateAllElementIdList(self)


    def isPopulatedAllElementIdList(self):
        """
        isPopulatedAllElementIdList(Model self) -> bool


        Predicate returning 'True' if libSBML has a list of the ids of all
        components of this model.

        Returns 'True' if the id list has already been populated, 'False'
        otherwise.

        """
        return _libsbml.Model_isPopulatedAllElementIdList(self)


    def getAllElementIdList(self):
        """
        getAllElementIdList(Model self) -> IdList


        Returns the internal list of the identifiers of all elements within
        this Model object.

        Returns an IdList of all the identifiers in the model.

        See also populateAllElementIdList(), isPopulatedAllElementIdList().

        """
        return _libsbml.Model_getAllElementIdList(self)


    def clearAllElementIdList(self):
        """
        clearAllElementIdList(Model self)


        Clears the internal list of the identifiers of all elements within
        this Model object.

        See also populateAllElementIdList(), isPopulatedAllElementIdList().

        """
        return _libsbml.Model_clearAllElementIdList(self)


    def populateAllElementMetaIdList(self):
        """
        populateAllElementMetaIdList(Model self)


        Populates the internal list of the metaids of all elements within this
        Model object.

        This method tells libSBML to retrieve the identifiers of all elements
        of the enclosing Model object.  The result is stored in an internal
        list of metaids.  Users can access the resulting data by calling the
        method getAllElementMetaIdList().

        WARNING:

        Retrieving all elements within a model is a time-consuming operation.
        Callers may want to call isPopulatedAllElementMetaIdList() to
        determine whether the metaid list may already have been populated.

        See also isPopulatedAllElementMetaIdList().

        """
        return _libsbml.Model_populateAllElementMetaIdList(self)


    def isPopulatedAllElementMetaIdList(self):
        """
        isPopulatedAllElementMetaIdList(Model self) -> bool


        Predicate returning 'True' if libSBML has a list of the metaids of all
        components of this model.

        Returns 'True' if the metaid list has already been populated, 'False'
        otherwise.

        """
        return _libsbml.Model_isPopulatedAllElementMetaIdList(self)


    def getAllElementMetaIdList(self):
        """
        getAllElementMetaIdList(Model self) -> IdList


        Returns the internal list of the metaids of all elements within this
        Model object.

        Returns an IdList of all the metaids in the model.

        See also populateAllElementMetaIdList(),
        isPopulatedAllElementMetaIdList().

        """
        return _libsbml.Model_getAllElementMetaIdList(self)


    def clearAllElementMetaIdList(self):
        """
        clearAllElementMetaIdList(Model self)


        Clears the internal list of the metaids of all elements within this
        Model object.

        See also populateAllElementMetaIdList(),
        isPopulatedAllElementMetaIdList().

        """
        return _libsbml.Model_clearAllElementMetaIdList(self)


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


        Predicate returning 'True' if all the required elements for this Model
        object have been set.

        Returns 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(Model self, unsigned int n) -> FunctionDefinition
        removeFunctionDefinition(Model self, string sid) -> FunctionDefinition


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeFunctionDefinition(long n)

        Removes the nth FunctionDefinition object from this Model object and
        returns a pointer to it.

        The caller owns the returned object and is responsible for deleting
        it.

        Parameter 'n' is the index of the FunctionDefinition object to remove.

        Returns the FunctionDefinition object removed, or 'None' if the given
        index is out of range.

        ______________________________________________________________________
        Method variant with the following signature:

            removeFunctionDefinition(string sid)

        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.

        Parameter 'sid' is the identifier of the FunctionDefinition object to
        remove.

        Returns the FunctionDefinition object removed, or 'None' if no
        FunctionDefinition object with the identifier exists in this Model
        object.

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


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeUnitDefinition(long n)

        Removes the nth UnitDefinition object from this Model object and
        returns a pointer to it.

        The caller owns the returned object and is responsible for deleting
        it.

        Parameter 'n' is the index of the UnitDefinition object to remove.

        Returns the UnitDefinition object removed., or 'None' if the given
        index is out of range.

        ______________________________________________________________________
        Method variant with the following signature:

            removeUnitDefinition(string sid)

        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.

        Parameter 'sid' is the identifier of the UnitDefinition object to
        remove.

        Returns the UnitDefinition object removed, or 'None' if no
        UnitDefinition object with the identifier exists in this Model object.

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


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeCompartmentType(long n)

        Removes the nth CompartmentType object from this Model object and
        returns a pointer to it.

        The caller owns the returned object and is responsible for deleting
        it.

        Parameter 'n' is the index of the CompartmentType object to remove.

        Returns the ComapartmentType object removed, or 'None' if the given
        index is out of range.

        ______________________________________________________________________
        Method variant with the following signature:

            removeCompartmentType(string sid)

        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.

        Parameter 'sid' is the identifier of the object to remove.

        Returns the CompartmentType object removed, or 'None' if no
        CompartmentType object with the identifier exists in this Model
        object.

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


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeSpeciesType(long n)

        Removes the nth SpeciesType object from this Model object and returns
        a pointer to it.

        The caller owns the returned object and is responsible for deleting
        it.

        Parameter 'n' is the index of the SpeciesType object to remove.

        Returns the SpeciesType object removed, or 'None' if the given index
        is out of range.

        ______________________________________________________________________
        Method variant with the following signature:

            removeSpeciesType(string sid)

        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.

        Parameter 'sid' is the identifier of the SpeciesType object to remove.

        Returns the SpeciesType object removed, or 'None' if no SpeciesType
        object with the identifier exists in this Model object.

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


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeCompartment(long n)

        Removes the nth Compartment object from this Model object and returns
        a pointer to it.

        The caller owns the returned object and is responsible for deleting
        it.

        Parameter 'n' is the index of the Compartment object to remove.

        Returns the Compartment object removed, or 'None' if the given index
        is out of range.

        ______________________________________________________________________
        Method variant with the following signature:

            removeCompartment(string sid)

        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.

        Parameter 'sid' is the identifier of the Compartment object to remove.

        Returns the Compartment object removed, or 'None' if no Compartment
        object with the identifier exists in this Model object.

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


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeSpecies(long n)

        Removes the nth Species object from this Model object and returns a
        pointer to it.

        The caller owns the returned object and is responsible for deleting
        it.

        Parameter 'n' is the index of the Species object to remove.

        Returns the Species object removed, or 'None' if the given index is
        out of range.

        ______________________________________________________________________
        Method variant with the following signature:

            removeSpecies(string sid)

        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.

        Parameter 'sid' is the identifier of the Species object to remove.

        Returns the Species object removed, or 'None' if no Species object
        with the identifier exists in this Model object.

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


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeParameter(long n)

        Removes the nth Parameter object from this Model object and returns a
        pointer to it.

        The caller owns the returned object and is responsible for deleting
        it.

        Parameter 'n' is the index of the Parameter object to remove.

        Returns the Parameter object removed, or 'None' if the given index is
        out of range.

        ______________________________________________________________________
        Method variant with the following signature:

            removeParameter(string sid)

        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.

        Parameter 'sid' is the identifier of the Parameter object to remove.

        Returns the Parameter object removed, or 'None' if no Parameter object
        with the identifier exists in this Model object.

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


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeInitialAssignment(string symbol)

        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.

        Parameter 'symbol' is the 'symbol' attribute of the InitialAssignment
        object to remove.

        Returns the InitialAssignment object removed, or 'None' if no
        InitialAssignment object with the 'symbol' attribute exists in this
        Model object.

        ______________________________________________________________________
        Method variant with the following signature:

            removeInitialAssignment(long n)

        Removes the nth InitialAssignment object from this Model object and
        returns a pointer to it.

        The caller owns the returned object and is responsible for deleting
        it.

        Parameter 'n' is the index of the InitialAssignment object to remove.

        Returns the InitialAssignment object removed, or 'None' if the given
        index is out of range.

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


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeRule(string variable)

        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.

        Parameter 'variable' is the 'variable' attribute of the Rule object to
        remove.

        Returns the Rule object removed, or 'None' if no Rule object with the
        'variable' attribute exists in this Model object.

        ______________________________________________________________________
        Method variant with the following signature:

            removeRule(long n)

        Removes the nth Rule object from this Model object and returns a
        pointer to it.

        The caller owns the returned object and is responsible for deleting
        it.

        Parameter 'n' is the index of the Rule object to remove.

        Returns the Rule object removed, or 'None' if the given index is out
        of range.

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


    def removeRuleByVariable(self, variable):
        """
        removeRuleByVariable(Model 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.

        Parameter 'variable' is the 'variable' attribute of the Rule object to
        remove.

        Returns the Rule object removed, or 'None' if no Rule object with the
        'variable' attribute exists in this Model object.

        """
        return _libsbml.Model_removeRuleByVariable(self, variable)


    def removeConstraint(self, n):
        """
        removeConstraint(Model 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.

        Parameter 'n' is the index of the Constraint object to remove.

        Returns the Constraint object removed, or 'None' if the given index is
        out of range.

        """
        return _libsbml.Model_removeConstraint(self, n)


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeReaction(long n)

        Removes the nth Reaction object from this Model object and returns a
        pointer to it.

        The caller owns the returned object and is responsible for deleting
        it.

        Parameter 'n' is the index of the Reaction object to remove.

        Returns the Reaction object removed, or 'None' if the given index is
        out of range.

        ______________________________________________________________________
        Method variant with the following signature:

            removeReaction(string sid)

        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.

        Parameter 'sid' is the identifier of the Reaction object to remove.

        Returns the Reaction object removed, or 'None' if no Reaction object
        with the identifier exists in this Model object.

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


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeEvent(long n)

        Removes the nth Event object from this Model object and returns a
        pointer to it.

        The caller owns the returned object and is responsible for deleting
        it.

        Parameter 'n' is the index of the Event object to remove.

        Returns the Event object removed, or 'None' if the given index is out
        of range.

        ______________________________________________________________________
        Method variant with the following signature:

            removeEvent(string sid)

        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.

        Parameter 'sid' is the identifier of the Event object to remove.

        Returns the Event object removed, or 'None' if no Event object with
        the identifier exists in this Model object.

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


    def appendFrom(self, model):
        """
        appendFrom(Model self, Model model) -> int


        Copies a given Model object's subcomponents and appends the copies to
        the appropriate places in this Model.

        This method also calls the appendFrom method on all libSBML plug-in
        objects.

        SBML Level 3 consists of a Core definition that can be extended via
        optional SBML Level 3 packages.  A given model may indicate that it
        uses one or more SBML packages, and likewise, a software tool may be
        able to support one or more packages.  LibSBML does not come
        preconfigured with all possible packages included and enabled, in part
        because not all package specifications have been finalized.  To
        support the ability for software systems to enable support for the
        Level 3 packages they choose, libSBML features a plug-in mechanism.
        Each SBML Level 3 package is implemented in a separate code plug-in
        that can be enabled by the application to support working with that
        SBML package.  A given SBML model may thus contain not only objects
        defined by SBML Level 3 Core, but also objects created by libSBML
        plug-ins supporting additional Level 3 packages.

        Parameter 'model' is the Model to merge with this one.

        """
        return _libsbml.Model_appendFrom(self, model)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(Model self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.Model_enablePackageInternal(self, pkgURI, pkgPrefix, flag)


    def updateSBMLNamespace(self, package, level, version):
        """
        updateSBMLNamespace(Model self, string package, unsigned int level, unsigned int version)


        Internal implementation method.

        """
        return _libsbml.Model_updateSBMLNamespace(self, package, level, version)


    def renameIDs(self, elements, idTransformer):
        """
        renameIDs(Model self, SBaseList elements, IdentifierTransformer idTransformer)


        Internal implementation method.

        """
        return _libsbml.Model_renameIDs(self, elements, idTransformer)

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):
    """

    Overall SBML container 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).  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.

    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 Sbml defined in the SBML
    Level 2 specification and SBML in the Level 3 specification.  It does
    not have a direct correspondence in SBML Level 1.  (However, to make
    matters simpler for applications, libSBML creates an SBMLDocument no
    matter whether the model is Level 1, Level 2 or Level 3.)  In its
    barest form, when written out in XML format for (e.g.) SBML Level 2
    Version 4, the corresponding structure is the following:

      <sbml xmlns='http://www.sbml.org/sbml/level2/version4' level='2' version='4'>
        ...
      </sbml>

    SBMLDocument is derived from SBase, and therefore contains the usual
    SBase attributes (in SBML Level 2 and Level 3) 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.

    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 were
    quite lenient, and allowed a caller to compose SBML entities that
    might not, in the end, represent valid SBML.  This allowed
    applications the freedom to do things such as save incomplete models
    (which is useful when models are being developed over long periods of
    time).  In the version 4.x series, libSBML is somewhat stricter, but
    still permits structures to be created independently and the results
    to be combined in a separate step.  In all these cases, 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 validation 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).

    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.

    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 list summarizes the
    possible scenarios.

    Scenario 1: Creating a model from scratch.  Before writing out the
    model,

    * Call SBMLDocument.checkInternalConsistency(), then inquire about
    the results by calling SBMLDocument.getNumErrors()

    * Call SBMLDocument.setConsistencyChecks()  to configure which
    checks will be performed by SBMLDocument.checkConsistency()

    * Call SBMLDocument.checkConsistency(), then inquire about the
    results by calling SBMLDocument.getNumErrors()

    Scenario 2: Reading a model from a file or data stream. After reading
    the model,

    * Basic consistency checks will have been performed automatically
    by libSBML upon reading the content, so you only need to inquire about
    the results by using SBMLDocument.getNumErrors()

    * Call SBMLDocument.setConsistencyChecks()  to configure which
    checks are performed by SBMLDocument.checkConsistency()

    * Call SBMLDocument.checkConsistency(), then inquire about the
    results by calling SBMLDocument.getNumErrors()

    It should be noted that as of SBML Level 3 Version 2, the Model
    became an optional child of SBMLDocument, instead of being required.
    This means that one can no longer use SBMLDocument.getModel() as a
    cheap method of checking if an SBML document was read in properly: the
    more robust getError methods detailed above must be used instead.

    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 setLevelAndVersion() .  In  general, models can be converted
    upward without difficulty (e.g., from SBML Level 1 to Level 2, or from
    an earlier Version of Level 2 to the latest Version of Level 2).
    Sometimes models can be translated downward as well, if they do not
    use constructs specific to more advanced Levels of SBML.

    Calling SBMLDocument.setLevelAndVersion()  will not 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
    SBMLDocument.setLevelAndVersion()  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:

    * SBMLDocument.checkL1Compatibility(),

    * SBMLDocument.checkL2v1Compatibility(),

    * SBMLDocument.checkL2v2Compatibility(),

    * SBMLDocument.checkL2v3Compatibility(),

    * SBMLDocument.checkL2v4Compatibility(),

    * SBMLDocument.checkL2v5Compatibility(), and

    * SBMLDocument.checkL3v1Compatibility().

    Some changes between Versions of SBML Level 2 may lead to unexpected
    behaviors when attempting conversions in either direction. For
    example, SBML Level 2 Version 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 4, if
    converted to Version 3 with no other changes, may fail validation as a
    Version 3 model because Version 3 imposed stricter requirements on
    unit consistency.

    Other changes between SBML Level 2 and Level 3 make downward
    conversions challenging.  In some cases, it means that a model
    converted to Level 2 from Level 3 will contain attributes that were
    not explicitly given in the Level 3 model, because in Level 2 these
    attributes may have been optional or have default values.

    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(), SBMLDocument.getError()  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.

    """

    __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 libSBML version 5.18.0  was
        released.  The default Level is used by SBMLDocument if no Level is
        explicitly specified at the time of the construction of an
        SBMLDocument instance.

        Returns an integer indicating the most recent SBML specification
        Level.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        See also SBMLDocument.getDefaultVersion() .

        """
        return _libsbml.SBMLDocument_getDefaultLevel()

    getDefaultLevel = staticmethod(getDefaultLevel)

    def getDefaultVersion():
        """
        getDefaultVersion() -> unsigned int


        The default Version of new SBMLDocument objects.

        This 'default Version' corresponds to the most recent Version within
        the most recent Level of SBML available at the time libSBML version
        5.18.0  was released.  The default Version is used by SBMLDocument if
        no Version is explicitly specified at the time of the construction of
        an SBMLDocument instance.

        Returns an integer indicating the most recent SBML specification
        Version.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        See also SBMLDocument.getDefaultLevel() .

        """
        return _libsbml.SBMLDocument_getDefaultVersion()

    getDefaultVersion = staticmethod(getDefaultVersion)
    __swig_destroy__ = _libsbml.delete_SBMLDocument
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(SBMLDocument self, unsigned int level=0, unsigned int version=0) -> SBMLDocument
        __init__(SBMLDocument self, unsigned int level=0) -> SBMLDocument
        __init__(SBMLDocument self) -> SBMLDocument
        __init__(SBMLDocument self, SBMLNamespaces sbmlns) -> SBMLDocument
        __init__(SBMLDocument self, SBMLDocument orig) -> SBMLDocument


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            SBMLDocument(SBMLNamespaces sbmlns)

        Creates a new SBMLDocument using the given SBMLNamespaces object
        'sbmlns'.

        The SBMLNamespaces object encapsulates SBML Level/Version/namespaces
        information.  It is used to communicate the SBML Level, Version, and
        (in Level 3) packages used in addition to SBML Level 3 Core.  A common
        approach to using libSBML's SBMLNamespaces facilities is to create an
        SBMLNamespaces object somewhere in a program once, then hand that
        object as needed to object constructors that accept SBMLNamespaces as
        arguments.

        Parameter 'sbmlns' is an SBMLNamespaces object.

        Throws SBMLConstructorException: Thrown if the given 'sbmlns' is
        inconsistent or incompatible with this object.

        ______________________________________________________________________
        Method variant with the following signature:

            SBMLDocument(long level = 0, long version = 0)

        Creates a new SBMLDocument, optionally with given values for the SBML
        Level and Version.

        If both the SBML Level and Version attributes are not specified, the
        SBML document is treated as having the latest Level and Version of
        SBML as determined by SBMLDocument.getDefaultLevel() and
        SBMLDocument.getDefaultVersion(); however, the SBMLDocument object is
        otherwise left blank.  In particular, the blank SBMLDocument object
        has no associated XML attributes, including (but not limited to) an
        XML namespace declaration.  The XML namespace declaration is not added
        until the model is written out, or the method
        SBMLDocument.setLevelAndVersion() is called.  This may be important to
        keep in mind if an application needs to add additional XML namespace
        declarations on the <sbml> element.  Application writers should either
        provide values for 'level' and 'version' on the call to this
        constructor, or else call SBMLDocument.setLevelAndVersion() shortly
        after creating the SBMLDocument object.

        Parameter 'level' is an integer for the SBML Level.

        Parameter 'version' is an integer for the Version within the SBML
        Level.

        Throws SBMLConstructorException: Thrown if the given 'level' and
        'version' combination are invalid or if this object is incompatible
        with the given level and version.

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        See also SBMLDocument.setLevelAndVersion(), getDefaultLevel(),
        getDefaultVersion().

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            SBMLDocument(SBMLDocument orig)

        Copy constructor; creates a copy of this SBMLDocument.

        Parameter 'orig' is the object to copy.

        """
        this = _libsbml.new_SBMLDocument(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(SBMLDocument self) -> SBMLDocument


        Creates and returns a deep copy of this SBMLDocument object.

        Returns the (deep) copy of this SBMLDocument object.

        """
        return _libsbml.SBMLDocument_clone(self)


    def isSetModel(self):
        """
        isSetModel(SBMLDocument self) -> bool


        Returns 'True' if the Model object has been set, otherwise  returns
        'False.'

        Returns 'True' if the Model object has been set

        """
        return _libsbml.SBMLDocument_isSetModel(self)


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


      Returns the Model object stored in this SBMLDocument.

      It is important to note that this method does not create a Model
      instance.  The model in the SBMLDocument must have been created at
      some prior time, for example using SBMLDocument.createModel()  or
      SBMLDocument.setModel(). This method returns 'None' if a model does
      not yet exist.

      Returns the Model contained in this SBMLDocument, or 'None' if no such
      model exists.

      See also createModel().

      """
      model = _libsbml.SBMLDocument_getModel(self, *args)
      if model is not None:
        model.__parent_ref__ = self
      return model



    def getElementBySId(self, id):
        """
        getElementBySId(SBMLDocument self, string id) -> SBase


        Returns the first child element found that has the given 'id' in the
        model-wide SId namespace, or 'None' if no such object is found.

        Parameter 'id' is string representing the id of the object to find.

        Returns pointer to the first element found with the given 'id'.

        """
        return _libsbml.SBMLDocument_getElementBySId(self, id)


    def getElementByMetaId(self, metaid):
        """
        getElementByMetaId(SBMLDocument self, string metaid) -> SBase


        Returns the first child element it can find with the given 'metaid',
        or itself if it has the given 'metaid', or 'None' if no such object is
        found.

        Parameter 'metaid' is string representing the metaid of the object to
        find.

        Returns pointer to the first element found with the given 'metaid'.

        """
        return _libsbml.SBMLDocument_getElementByMetaId(self, metaid)


    def expandFunctionDefinitions(self):
        """
        expandFunctionDefinitions(SBMLDocument self) -> bool


        Removes FunctionDefinition constructs from the document and expands
        any instances of their use within <math> elements.

        For example, suppose a Model contains a FunctionDefinition with
        identifier ''f'' representing the math expression: f(x, y) = x * y.
        Suppose further that there is a reaction in which the <math> element
        of the KineticLaw object contains f(s, p), where 's' and 'p' are other
        identifiers defined in the model.  The outcome of invoking this method
        is that the <math> of the KineticLaw now represents the expression s *
        p and the model no longer contains any FunctionDefinition objects.

        Returns bool 'True' if the transformation was successful,  'False,'
        otherwise.

        Note: This function will check the consistency of a model before
        attemptimg the transformation.  If the model is not valid SBML, the
        transformation will not be performed and the function will return
        'False.'

        """
        return _libsbml.SBMLDocument_expandFunctionDefinitions(self)


    def expandInitialAssignments(self):
        """
        expandInitialAssignments(SBMLDocument self) -> bool


        Removes InitialAssignment constructs from the document and replaces
        them with appropriate values.

        For example, suppose a Model contains a InitialAssignment to a symbol
        ''k'' where ''k'' is the identifier of a Parameter.  The outcome of
        invoking this method is that the 'value' attribute of the Parameter
        definition is set to the result calculated using the InitialAssignment
        object's <math> formula, and the corresponding InitialAssignment is
        then removed from the Model.

        Returns bool 'True' if the transformation was successful,  'False,'
        otherwise.

        Note: This function will check the consistency of a model before
        attemptimg the transformation.  If the model is not valid SBML, the
        transformation will not be performed and the function will return
        'False.'  As part of that process, this method will check that it has
        values for any components referred to by the <math> elements of
        InitialAssignment objects.  In cases where not all of the values have
        been declared (e.g., if the mathematical expression refers to model
        entities that have no declared values), the InitialAssignment in
        question will not be removed and this method will return 'False.'

        """
        return _libsbml.SBMLDocument_expandInitialAssignments(self)


    def setLevelAndVersion(self, level, version, strict=True, ignorePackages=False):
        """
        setLevelAndVersion(SBMLDocument self, unsigned int level, unsigned int version, bool strict=True, bool ignorePackages=False) -> bool
        setLevelAndVersion(SBMLDocument self, unsigned int level, unsigned int version, bool strict=True) -> bool
        setLevelAndVersion(SBMLDocument 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 1 to Level 2, or from
        an earlier Version of Level 2 to the latest Version of Level 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(),
        SBMLDocument.checkL2v4Compatibility(),
        SBMLDocument.checkL2v5Compatibility(),
        SBMLDocument.checkL3v1Compatibility(), and
        SBMLDocument.checkL3v2Compatibility().

        The valid combinations of SBML Level and Version as of this release of
        libSBML are the following:

        * Level 1 Version 2

        * Level 2 Version 1

        * Level 2 Version 2

        * Level 2 Version 3

        * Level 2 Version 4

        * Level 2 Version 5

        * Level 3 Version 1

        * Level 3 Version 2 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() method.  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.

        Parameter 'level' is the desired SBML Level.

        Parameter 'version' is the desired Version within the SBML Level.

        Parameter 'strict' is boolean indicating whether to check consistency
        of both the source and target model when performing conversion
        (defaults to  true ).

        Parameter 'ignorePackages' is boolean indicating whether the presence
        of packages should be ignored by the conversion routine  (defaults to
        false ).

        Returns 'True' if the level and version of the document were
        successfully set to the requested values (which may have required
        conversion of the model), 'False' otherwise.

        Note: Calling this method will not 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 2 to Level 1, callers can also
        check the Level of the model after calling this method to find out
        whether it is Level 1.  (If the conversion to Level 1 failed, the
        Level of this model will be left unchanged.)

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        See also checkL1Compatibility(), checkL2v1Compatibility(),
        checkL2v2Compatibility(), checkL2v3Compatibility(),
        checkL2v4Compatibility(), checkL2v5Compatibility(),
        checkL3v1Compatibility().

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        return _libsbml.SBMLDocument_setLevelAndVersion(self, level, version, strict, ignorePackages)


    def updateSBMLNamespace(self, package, level, version):
        """
        updateSBMLNamespace(SBMLDocument self, string package, unsigned int level, unsigned int version)


        Internal implementation method.

        """
        return _libsbml.SBMLDocument_updateSBMLNamespace(self, package, level, version)


    def setModel(self, m):
        """
        setModel(SBMLDocument self, Model m) -> int


        Sets the Model for this SBMLDocument to a copy of the given Model.

        Parameter 'm' is the new Model to use.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        See also createModel(), getModel().

        """
        return _libsbml.SBMLDocument_setModel(self, m)


    def createModel(self, *args):
        """
        createModel(SBMLDocument self, string sid) -> Model
        createModel(SBMLDocument self) -> Model


        Creates a new Model inside this SBMLDocument, and returns a pointer to
        it.

        In SBML Level 2, the use of an identifier on a Model object is
        optional.  This method takes an optional argument, 'sid', for setting
        the identifier.  If not supplied, the identifier attribute on the
        Model instance is not set.

        Parameter 'sid' is the identifier of the new Model to create.

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        See also getModel(), SBMLDocument.setModel().

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

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


    def setLocationURI(self, uri):
        """
        setLocationURI(SBMLDocument self, string uri)


        Sets the location of this SBMLDocument.

        Called automatically when readSBMLFromFile is used, but may be set
        manually as well.

        """
        return _libsbml.SBMLDocument_setLocationURI(self, uri)


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


        Get the location of this SBMLDocument.

        If this document was read from a file or had its location set
        manually, that filename or set location will be returned, otherwise,
        an empty string is returned.

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


    def setConsistencyChecks(self, category, apply):
        """
        setConsistencyChecks(SBMLDocument 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 ('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 ('apply', a boolean) indicates whether to turn it on
        (value of 'True)' or off (value of 'False).'

        The possible categories (values to the argument 'category') are the
        set of constants whose names begin with the characters LIBSBML_CAT_ in
        the interface class libsbml. The following are the possible choices:

        * 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 2 Versions 2-4 and Level 3 Versions 1-2 specifications.

        * 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 2 Versions 2-4 and Level 3 Versions 1-2
        specifications.

        * 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 2 Versions 2-4 and Level 3 Versions 1-2
        specifications.

        * 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 2 Versions 2-4 and
        Level 3 Versions 1-2 specifications.

        * 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 2 Versions 2-4 and Level 3 Versions 1-2
        specifications.

        * 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 Level 2 Versions 2-4 and Level 3
        Versions 1-2 specifications.

        * 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.)  By default, all
        validation checks are applied to the model in an SBMLDocument object
        unless SBMLDocument.setConsistencyChecks() is called to indicate that
        only a subset should be applied.  Further, this default (i.e.,
        performing all checks) applies separately to each new SBMLDocument
        object created.  In other words, each time a model is read using
        SBMLReader.readSBML(), SBMLReader.readSBMLFromString(), 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
        SBMLDocument.setConsistencyChecks() for each such new model if they
        wish to change the consistency checks applied.

        Parameter 'category' is a value drawn from the set of SBML error
        categories indicating the consistency checking/validation to be turned
        on or off.

        Parameter 'apply' is a boolean indicating whether the checks indicated
        by 'category' should be applied or not.

        See also SBMLDocument.checkConsistency().

        """
        return _libsbml.SBMLDocument_setConsistencyChecks(self, category, apply)


    def setConsistencyChecksForConversion(self, category, apply):
        """
        setConsistencyChecksForConversion(SBMLDocument self, SBMLErrorCategory_t category, bool apply)


        Controls the consistency checks that are performed when
        SBMLDocument.setLevelAndVersion() 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 ('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 ('apply', a boolean) indicates whether to turn
        it on (value of 'True)' or off (value of 'False).'

        The possible categories (values to the argument 'category') are the
        set of constants whose names begin with the characters LIBSBML_CAT_ in
        the interface class libsbml. The following are the possible choices:

        * 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 2 Versions 2-4 and Level 3 Versions 1-2 specifications.

        * 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 2 Versions 2-4 and Level 3 Versions 1-2
        specifications.

        * 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 2 Versions 2-4 and Level 3 Versions 1-2
        specifications.

        * 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 2 Versions 2-4 and
        Level 3 Versions 1-2 specifications.

        * 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 2 Versions 2-4 and Level 3 Versions 1-2
        specifications.

        * 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 Level 2 Versions 2-4 and Level 3
        Versions 1-2 specifications.

        * 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.) By default, all validation
        checks are applied to the model in an SBMLDocument object unless
        SBMLDocument.setConsistencyChecks() is called to indicate that only a
        subset should be applied.  Further, this default (i.e., performing all
        checks) applies separately to each new SBMLDocument object created.
        In other words, each time a model is read using SBMLReader.readSBML(),
        SBMLReader.readSBMLFromString(), 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
        SBMLDocument.setConsistencyChecks() for each such new model if they
        wish to change the consistency checks applied.

        Parameter 'category' is a value drawn from the set of SBML error
        categories indicating the consistency checking/validation to be turned
        on or off.

        Parameter 'apply' is a boolean indicating whether the checks indicated
        by 'category' should be applied or not.

        See also SBMLDocument.setLevelAndVersion().

        """
        return _libsbml.SBMLDocument_setConsistencyChecksForConversion(self, category, apply)


    def checkConsistency(self):
        """
        checkConsistency(SBMLDocument 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 or errors.  Callers should inspect the severity flag
        in the individual SBMLError objects returned by
        SBMLDocument.getError() to determine the nature of the failures.

        Returns the number of failed checks (errors) encountered.

        See also SBMLDocument.checkInternalConsistency().

        """
        return _libsbml.SBMLDocument_checkConsistency(self)


    def checkConsistencyWithStrictUnits(self):
        """
        checkConsistencyWithStrictUnits(SBMLDocument self) -> unsigned int


        Performs consistency checking and validation on this SBML document
        using the ultra strict units validator that assumes that there are no
        hidden numerical conversion factors.

        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 or errors.  Callers should inspect the severity flag
        in the individual SBMLError objects returned by
        SBMLDocument.getError() to determine the nature of the failures.

        Returns the number of failed checks (errors) encountered.

        See also SBMLDocument.checkInternalConsistency().

        """
        return _libsbml.SBMLDocument_checkConsistencyWithStrictUnits(self)


    def validateSBML(self):
        """
        validateSBML(SBMLDocument 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 or errors.  Callers should inspect the severity flag
        in the individual SBMLError objects returned by
        SBMLDocument.getError() to determine the nature of the failures.

        Note: unlike checkConsistency this method will write the document in
        order to determine all errors for the document. This will  also clear
        the error log.

        Returns the number of failed checks (errors) encountered.

        See also SBMLDocument.checkConsistency().

        """
        return _libsbml.SBMLDocument_validateSBML(self)


    def checkInternalConsistency(self):
        """
        checkInternalConsistency(SBMLDocument 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
        SBMLDocument.getError().

        Returns 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 2
        Versions 2-4 specification documents.

        See also SBMLDocument.checkConsistency().

        """
        return _libsbml.SBMLDocument_checkInternalConsistency(self)


    def checkL1Compatibility(self, inConversion=False):
        """
        checkL1Compatibility(SBMLDocument self, bool inConversion=False) -> unsigned int
        checkL1Compatibility(SBMLDocument self) -> unsigned int


        Performs a set of consistency checks on the document to establish
        whether it is compatible with SBML Level 1 and can be converted to
        Level 1.

        Callers should query the results of the consistency check by calling
        SBMLDocument.getError().

        Returns the number of failed checks (errors) encountered.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        return _libsbml.SBMLDocument_checkL1Compatibility(self, inConversion)


    def checkL2v1Compatibility(self, inConversion=False):
        """
        checkL2v1Compatibility(SBMLDocument self, bool inConversion=False) -> unsigned int
        checkL2v1Compatibility(SBMLDocument self) -> unsigned int


        Performs a set of consistency checks on the document to establish
        whether it is compatible with SBML Level 2 Version 1 and can be
        converted to Level 2 Version 1.

        Callers should query the results of the consistency check by calling
        SBMLDocument.getError().

        Returns the number of failed checks (errors) encountered.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        return _libsbml.SBMLDocument_checkL2v1Compatibility(self, inConversion)


    def checkL2v2Compatibility(self, inConversion=False):
        """
        checkL2v2Compatibility(SBMLDocument self, bool inConversion=False) -> unsigned int
        checkL2v2Compatibility(SBMLDocument self) -> unsigned int


        Performs a set of consistency checks on the document to establish
        whether it is compatible with SBML Level 2 Version 2 and can be
        converted to Level 2 Version 2.

        Callers should query the results of the consistency check by calling
        SBMLDocument.getError().

        Returns the number of failed checks (errors) encountered.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        return _libsbml.SBMLDocument_checkL2v2Compatibility(self, inConversion)


    def checkL2v3Compatibility(self, inConversion=False):
        """
        checkL2v3Compatibility(SBMLDocument self, bool inConversion=False) -> unsigned int
        checkL2v3Compatibility(SBMLDocument self) -> unsigned int


        Performs a set of consistency checks on the document to establish
        whether it is compatible with SBML Level 2 Version 3 and can be
        converted to Level 2 Version 3.

        Callers should query the results of the consistency check by calling
        SBMLDocument.getError().

        Returns the number of failed checks (errors) encountered.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        return _libsbml.SBMLDocument_checkL2v3Compatibility(self, inConversion)


    def checkL2v4Compatibility(self):
        """
        checkL2v4Compatibility(SBMLDocument self) -> unsigned int


        Performs a set of consistency checks on the document to establish
        whether it is compatible with SBML Level 2 Version 4 and can be
        converted to Level 2 Version 4.

        Callers should query the results of the consistency check by calling
        SBMLDocument.getError().

        Returns the number of failed checks (errors) encountered.

        """
        return _libsbml.SBMLDocument_checkL2v4Compatibility(self)


    def checkL2v5Compatibility(self):
        """
        checkL2v5Compatibility(SBMLDocument self) -> unsigned int


        Performs a set of consistency checks on the document to establish
        whether it is compatible with SBML Level 2 Version 5 and can be
        converted to Level 2 Version 5.

        Callers should query the results of the consistency check by calling
        SBMLDocument.getError().

        Returns the number of failed checks (errors) encountered.

        """
        return _libsbml.SBMLDocument_checkL2v5Compatibility(self)


    def checkL3v1Compatibility(self):
        """
        checkL3v1Compatibility(SBMLDocument self) -> unsigned int


        Performs a set of consistency checks on the document to establish
        whether it is compatible with SBML Level 3 Version 1 and can be
        converted to Level 3 Version 1.

        Callers should query the results of the consistency check by calling
        SBMLDocument.getError().

        Returns the number of failed checks (errors) encountered.

        """
        return _libsbml.SBMLDocument_checkL3v1Compatibility(self)


    def checkL3v2Compatibility(self):
        """
        checkL3v2Compatibility(SBMLDocument self) -> unsigned int


        Performs a set of consistency checks on the document to establish
        whether it is compatible with SBML Level 3 Version 2 and can be
        converted to Level 3 Version 2.

        Callers should query the results of the consistency check by calling
        SBMLDocument.getError().

        Returns the number of failed checks (errors) encountered.

        """
        return _libsbml.SBMLDocument_checkL3v2Compatibility(self)


    def getError(self, n):
        """
        getError(SBMLDocument 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.

        Returns the error or warning indexed by integer 'n', or return 'None'
        if n > (getNumErrors() - 1).

        Parameter 'n' is the integer index of the error sought.

        See also SBMLDocument.getNumErrors().

        """
        return _libsbml.SBMLDocument_getError(self, n)


    def getErrorWithSeverity(self, n, severity):
        """
        getErrorWithSeverity(SBMLDocument self, unsigned int n, unsigned int severity) -> SBMLError


        Returns the nth error or warning with the given severity encountered
        during parsing, consistency checking, or attempted translation of this
        model.

        Returns the error or warning indexed by integer 'n', or return 'None'
        if n > (getNumErrors(severity) - 1).

        Parameter 'n' is the integer index of the error sought. Parameter
        'severity' is the severity of the error sought.

        See also SBMLDocument.getNumErrors().

        """
        return _libsbml.SBMLDocument_getErrorWithSeverity(self, n, severity)


    def getNumErrors(self, *args):
        """
        getNumErrors(SBMLDocument self) -> unsigned int
        getNumErrors(SBMLDocument self, unsigned int severity) -> unsigned int


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getNumErrors(long severity)

        Returns the number of errors or warnings encountered with the given
        severity during parsing, consistency checking, or attempted
        translation of this model.

        Parameter 'severity' is the severity of the error sought.

        Returns the number of errors or warnings encountered.

        See also SBMLDocument.getError().

        ______________________________________________________________________
        Method variant with the following signature:

            getNumErrors()

        Returns the number of errors or warnings encountered during parsing,
        consistency checking, or attempted translation of this model.

        Returns the number of errors or warnings encountered.

        See also SBMLDocument.getError().

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


    def printErrors(self, *args):
        """
        printErrors(SBMLDocument self, ostream stream)
        printErrors(SBMLDocument self)
        printErrors(SBMLDocument self, ostream stream, unsigned int severity)


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            printErrors(std::ostream& stream, long severity)

        Prints all the errors or warnings with the given severity encountered
        trying to parse, check, or translate this SBML document.

        It prints the text to the stream given by the parameter 'stream'.

        If no errors have occurred, i.e., getNumErrors(severity) == 0, no
        output will be sent to the stream.

        The format of the output is:

              N error(s):
                line NNN: (id) message

        Parameter 'stream' is the ostream or ostringstream object indicating
        where the output should be printed. Parameter 'severity' is of the
        errors sought.

        See also getNumErrors(), getErrorLog(),
        SBMLDocument.getErrorWithSeverity().

        ______________________________________________________________________
        Method variant with the following signature:

            printErrors(std::ostream& stream = std::cerr)

        Prints all the errors or warnings encountered trying to parse, check,
        or translate this SBML document.

        It prints the text to the stream given by the optional parameter
        'stream'.  If no parameter is given, it prints the output to the
        standard error stream.

        If no errors have occurred, i.e., getNumErrors() == 0, no output will
        be sent to the stream.

        The format of the output is:

             N error(s):
               line NNN: (id) message

        Parameter 'stream' is the ostream or ostringstream object indicating
        where the output should be printed.

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        See also getNumErrors(), getErrorLog(), SBMLDocument.getError().

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

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


    def connectToChild(self):
        """connectToChild(SBMLDocument self)"""
        return _libsbml.SBMLDocument_connectToChild(self)


    def convert(self, props):
        """
        convert(SBMLDocument self, ConversionProperties props) -> int


        Converts this document using the converter that best matches the given
        conversion properties.

        Parameter 'props' is the conversion properties to use.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_CONV_CONVERSION_NOT_AVAILABLE

        """
        return _libsbml.SBMLDocument_convert(self, props)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(SBMLDocument self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.SBMLDocument_enablePackageInternal(self, pkgURI, pkgPrefix, flag)


    def getTypeCode(self):
        """
        getTypeCode(SBMLDocument self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_DOCUMENT (default).

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also SBMLDocument.getElementName(), getPackageName().

        """
        return _libsbml.SBMLDocument_getTypeCode(self)


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


        Returns the XML element name of this object, which for SBMLDocument,
        is always ''sbml'.'

        Returns the name of this element, i.e., ''sbml'.'

        """
        return _libsbml.SBMLDocument_getElementName(self)


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


        Returns the list of errors or warnings logged during parsing,
        consistency checking, or attempted translation of this model.

        Returns the SBMLErrorLog used for this SBMLDocument.

        See also SBMLDocument.getNumErrors().

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


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


        Returns a list of XML Namespaces associated with the XML content of
        this SBML document.

        Returns the XML Namespaces associated with this SBML object.

        """
        return _libsbml.SBMLDocument_getNamespaces(self)


    def enableDefaultNS(self, package, flag):
        """
        enableDefaultNS(SBMLDocument self, string package, bool flag) -> int


        Set/unset default namespace to each top-level element defined in the
        given package extension.

        This works by adding a xmlns="..." attribute.  No prefix will be
        written when writing elements defined in the given package extension
        if 'True' is given as second argument.

        Parameter 'package' is the name or URI of the package extension.
        Parameter 'flag' is boolean value to indicate whether to write a
        namespace prefix.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_PKG_UNKNOWN_VERSION

        """
        return _libsbml.SBMLDocument_enableDefaultNS(self, package, flag)


    def isEnabledDefaultNS(self, package):
        """
        isEnabledDefaultNS(SBMLDocument self, string package) -> bool


        Returns 'True' if a default namespace is added to each top-level
        element defined in the given package extension, otherwise returns
        'False.'

        This basically checks if the attribute xmlns="..." is present.

        Parameter 'package' is the name or URI of the package extension.

        Returns a boolean indicating whether the given package's default
        namespace is enabled.

        """
        return _libsbml.SBMLDocument_isEnabledDefaultNS(self, package)


    def setPackageRequired(self, package, flag):
        """
        setPackageRequired(SBMLDocument self, string package, bool flag) -> int


        Sets the required attribute value of the given package extension.

        Parameter 'package' is the name or URI of the package extension.
        Parameter 'flag' is Boolean value indicating whether the package is
        required.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_PKG_UNKNOWN_VERSION

        """
        return _libsbml.SBMLDocument_setPackageRequired(self, package, flag)


    def getPackageRequired(self, package):
        """
        getPackageRequired(SBMLDocument self, string package) -> bool


        Returns the required attribute of the given package extension.

        Parameter 'package' is the name or URI of the package extension.

        Returns Boolean flag indicating whether the package is flagged as
        being required.

        """
        return _libsbml.SBMLDocument_getPackageRequired(self, package)


    def isSetPackageRequired(self, package):
        """
        isSetPackageRequired(SBMLDocument self, string package) -> bool


        Returns 'True' if the required attribute of the given package
        extension is defined, otherwise returns 'False.'

        Parameter 'package' is the name or URI of the package extension.

        Returns a Boolean indicating whether the package's 'required' flag is
        set.

        """
        return _libsbml.SBMLDocument_isSetPackageRequired(self, package)


    def isIgnoredPackage(self, pkgURI):
        """
        isIgnoredPackage(SBMLDocument self, string pkgURI) -> bool


        Returns 'True' if the given package extension is one of an ignored
        packages, otherwise returns 'False.'

        An ignored package is one that is defined to be used in this SBML
        document, but the package is not enabled in this copy of libSBML.

        Parameter 'pkgURI' is the URI of the package extension.

        Returns a Boolean, 'True' if the package is being ignored and 'False'
        otherwise.

        """
        return _libsbml.SBMLDocument_isIgnoredPackage(self, pkgURI)


    def isDisabledIgnoredPackage(self, pkgURI):
        """
        isDisabledIgnoredPackage(SBMLDocument self, string pkgURI) -> bool


        Returns 'True' if the given package extension is one of an ignored
        packages that has been disabled, otherwise returns 'False.'

        An ignored package is one that is defined to be used in this SBML
        document, but the package is not enabled in this copy of libSBML. It
        may have been disabled to avoid reproducing the package information
        when writing out the file.

        Parameter 'pkgURI' is the URI of the package extension.

        Returns a Boolean, 'True' if the package is being ignored and 'False'
        otherwise.

        """
        return _libsbml.SBMLDocument_isDisabledIgnoredPackage(self, pkgURI)


    def setPkgRequired(self, package, flag):
        """
        setPkgRequired(SBMLDocument self, string package, bool flag) -> int


        Sets the value of the required attribute for the given package.

        Parameter 'package' is the name or URI of the package extension.
        Parameter 'flag' is a Boolean value.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_PKG_UNKNOWN_VERSION

        DEPRECATED. Replaced in libSBML 5.2.0 by setPackageRequired()

        """
        return _libsbml.SBMLDocument_setPkgRequired(self, package, flag)


    def getPkgRequired(self, package):
        """
        getPkgRequired(SBMLDocument self, string package) -> bool


        Returns the required attribute of the given package extension.

        Parameter 'package' is the name or URI of the package extension.

        Returns a Boolean value indicating whether the package is flagged as
        being required in this SBML document.

        DEPRECATED. Replaced in libSBML 5.2.0 by getPackageRequired()

        """
        return _libsbml.SBMLDocument_getPkgRequired(self, package)


    def isSetPkgRequired(self, package):
        """
        isSetPkgRequired(SBMLDocument self, string package) -> bool


        Returns 'True' if the required attribute of the given package
        extension is defined, otherwise returns 'False.'

        Parameter 'package' is the name or URI of the package extension.

        Returns a Boolean value.

        DEPRECATED. Replaced in libSBML 5.2.0 by isSetPackageRequired()

        """
        return _libsbml.SBMLDocument_isSetPkgRequired(self, package)


    def isIgnoredPkg(self, pkgURI):
        """
        isIgnoredPkg(SBMLDocument self, string pkgURI) -> bool


        Returns 'True' if the given package extension is one of ignored
        packages, otherwise returns 'False.'

        An ignored package is one that is defined to be used in this SBML
        document, but the package is not enabled in this copy of libSBML.

        Parameter 'pkgURI' is the URI of the package extension.

        Returns a boolean indicating whether the given package is being
        ignored.

        DEPRECATED. Replaced in libSBML 5.2.0 by isIgnoredPackage()

        """
        return _libsbml.SBMLDocument_isIgnoredPkg(self, pkgURI)


    def getApplicableValidators(self):
        """
        getApplicableValidators(SBMLDocument self) -> unsigned char


        Internal implementation method.

        """
        return _libsbml.SBMLDocument_getApplicableValidators(self)


    def getConversionValidators(self):
        """
        getConversionValidators(SBMLDocument self) -> unsigned char


        Internal implementation method.

        """
        return _libsbml.SBMLDocument_getConversionValidators(self)


    def setApplicableValidators(self, appl):
        """
        setApplicableValidators(SBMLDocument self, unsigned char appl)


        Internal implementation method.

        """
        return _libsbml.SBMLDocument_setApplicableValidators(self, appl)


    def setConversionValidators(self, appl):
        """
        setConversionValidators(SBMLDocument self, unsigned char appl)


        Internal implementation method.

        """
        return _libsbml.SBMLDocument_setConversionValidators(self, appl)


    def getNumValidators(self):
        """
        getNumValidators(SBMLDocument self) -> unsigned int


        Internal implementation method.

        """
        return _libsbml.SBMLDocument_getNumValidators(self)


    def clearValidators(self):
        """
        clearValidators(SBMLDocument self) -> int


        Internal implementation method.

        """
        return _libsbml.SBMLDocument_clearValidators(self)


    def addValidator(self, validator):
        """
        addValidator(SBMLDocument self, SBMLValidator validator) -> int


        Internal implementation method.

        """
        return _libsbml.SBMLDocument_addValidator(self, validator)


    def getValidator(self, index):
        """
        getValidator(SBMLDocument self, unsigned int index) -> SBMLValidator


        Internal implementation method.

        """
        return _libsbml.SBMLDocument_getValidator(self, index)


    def addUnknownPackageRequired(self, pkgURI, prefix, flag):
        """
        addUnknownPackageRequired(SBMLDocument self, string pkgURI, string prefix, bool flag) -> int


        Internal implementation method.

        """
        return _libsbml.SBMLDocument_addUnknownPackageRequired(self, pkgURI, prefix, flag)


    def hasUnknownPackage(self, pkgURI):
        """
        hasUnknownPackage(SBMLDocument self, string pkgURI) -> bool


        Internal implementation method.

        """
        return _libsbml.SBMLDocument_hasUnknownPackage(self, pkgURI)


    def getNumUnknownPackages(self):
        """
        getNumUnknownPackages(SBMLDocument self) -> int


        Internal implementation method.

        """
        return _libsbml.SBMLDocument_getNumUnknownPackages(self)


    def getUnknownPackageURI(self, index):
        """
        getUnknownPackageURI(SBMLDocument self, int index) -> string


        Internal implementation method.

        """
        return _libsbml.SBMLDocument_getUnknownPackageURI(self, index)


    def getUnknownPackagePrefix(self, index):
        """
        getUnknownPackagePrefix(SBMLDocument self, int index) -> string


        Internal implementation method.

        """
        return _libsbml.SBMLDocument_getUnknownPackagePrefix(self, index)

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 libSBML version 5.18.0  was
    released.  The default Level is used by SBMLDocument if no Level is
    explicitly specified at the time of the construction of an
    SBMLDocument instance.

    Returns an integer indicating the most recent SBML specification
    Level.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    See also SBMLDocument.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 Version within
    the most recent Level of SBML available at the time libSBML version
    5.18.0  was released.  The default Version is used by SBMLDocument if
    no Version is explicitly specified at the time of the construction of
    an SBMLDocument instance.

    Returns an integer indicating the most recent SBML specification
    Version.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    See also SBMLDocument.getDefaultLevel() .

    """
    return _libsbml.SBMLDocument_getDefaultVersion()

class FunctionDefinition(SBase):
    """

    A user-defined function in an SBML model.

    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 '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 'math' subelement containing a MathML
    expression defining the function body.  In SBML Level 2 and SBML Level
    3 Version 1, that 'math' subelement is required; in SBML Level 3
    Version 2, this restriction was relaxed, making the 'math' subelement
    optional.  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 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 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 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.  In SBML Level 2, this restriction
    applies also to the MathML 'csymbol' elements for time and delay; in
    SBML Level 3, it additionally applies to the 'csymbol' element for
    avogadro.

    In SBML Level 3 Version 2, if no math element is present in  the
    FunctionDefinition, the function has no mathematical meaning  defined
    in SBML Level 3 Core. This situation may arise when models  are
    incomplete, or when additional meanings are provided by an SBML  Level
    3 package.

    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---they are simply macros.
    Software implementations therefore do not need the full function-
    definition machinery typically associated with programming languages.

    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__(FunctionDefinition self, unsigned int level, unsigned int version) -> FunctionDefinition
        __init__(FunctionDefinition self, SBMLNamespaces sbmlns) -> FunctionDefinition
        __init__(FunctionDefinition self, FunctionDefinition orig) -> FunctionDefinition


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            FunctionDefinition(SBMLNamespaces sbmlns)

        Creates a new FunctionDefinition using the given SBMLNamespaces object
        'sbmlns'.

        The SBMLNamespaces object encapsulates SBML Level/Version/namespaces
        information.  It is used to communicate the SBML Level, Version, and
        (in Level 3) packages used in addition to SBML Level 3 Core.  A common
        approach to using libSBML's SBMLNamespaces facilities is to create an
        SBMLNamespaces object somewhere in a program once, then hand that
        object as needed to object constructors that accept SBMLNamespaces as
        arguments.

        Parameter 'sbmlns' is an SBMLNamespaces object.

        Throws SBMLConstructorException: Thrown if the given 'sbmlns' is
        inconsistent or incompatible with this object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            FunctionDefinition(long level, long version)

        Creates a new FunctionDefinition using the given SBML 'level' and
        'version' values.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        FunctionDefinition.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this FunctionDefinition.

        Throws SBMLConstructorException: Thrown if the given 'level' and
        'version' combination are invalid or if this object is incompatible
        with the given level and version.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            FunctionDefinition(FunctionDefinition orig)

        Copy constructor; creates a copy of this FunctionDefinition.

        Parameter 'orig' is the object to copy.

        """
        this = _libsbml.new_FunctionDefinition(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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


        Creates and returns a deep copy of this FunctionDefinition object.

        Returns the (deep) copy of this FunctionDefinition object.

        """
        return _libsbml.FunctionDefinition_clone(self)


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


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

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is now recommended to use the
        getIdAttribute() function instead.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns the id of this FunctionDefinition.

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.FunctionDefinition_getId(self)


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


        Returns the value of the 'name' attribute of this FunctionDefinition
        object.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns the name of this SBML object, or the empty string if not set
        or unsettable.

        See also getIdAttribute(), isSetName(), setName(), unsetName().

        """
        return _libsbml.FunctionDefinition_getName(self)


    def getMath(self):
        """
        getMath(FunctionDefinition self) -> ASTNode


        Get the mathematical formula of this FunctionDefinition.

        Returns an ASTNode, the value of the 'math' subelement of this
        FunctionDefinition, or 'None' if the math is not set.

        """
        return _libsbml.FunctionDefinition_getMath(self)


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


        Predicate returning 'True' if this FunctionDefinition's 'id' attribute
        is set.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns 'True' if the 'id' attribute of this SBML object is set,
        'False' otherwise.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is recommended that callers use
        isSetIdAttribute() instead.

        See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(),
        isSetIdAttribute().

        """
        return _libsbml.FunctionDefinition_isSetId(self)


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


        Predicate returning 'True' if this FunctionDefinition's 'name'
        attribute is set.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns 'True' if the 'name' attribute of this SBML object is set,
        'False' otherwise.

        See also getName(), setName(), unsetName().

        """
        return _libsbml.FunctionDefinition_isSetName(self)


    def isSetMath(self):
        """
        isSetMath(FunctionDefinition self) -> bool


        Predicate returning 'True' if this FunctionDefinition's 'math'
        subelement contains a value.

        Returns 'True' if the 'math' for this FunctionDefinition is set,
        'False' otherwise.

        """
        return _libsbml.FunctionDefinition_isSetMath(self)


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


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

        The string 'sid' is copied.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Parameter 'sid' is the string to use as the identifier of this object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.FunctionDefinition_setId(self, sid)


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


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

        The string in 'name' is copied.

        Parameter 'name' is the new name for the SBML object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.FunctionDefinition_setName(self, name)


    def setMath(self, math):
        """
        setMath(FunctionDefinition self, ASTNode math) -> int


        Sets the 'math' subelement of this FunctionDefinition to the Abstract
        Syntax Tree given in 'math'.

        Parameter 'math' is an AST containing the mathematical expression to
        be used as the formula for this FunctionDefinition.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_OBJECT

        """
        return _libsbml.FunctionDefinition_setMath(self, math)


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


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

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getName(), setName(), isSetName().

        """
        return _libsbml.FunctionDefinition_unsetName(self)


    def getArgument(self, *args):
        """
        getArgument(FunctionDefinition self, unsigned int n) -> ASTNode
        getArgument(FunctionDefinition self, string name) -> ASTNode


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getArgument(long n)

        Get the nth argument to this function.

        Callers should first find out the number of arguments to the function
        by calling getNumArguments().

        Parameter 'n' is an integer index for the argument sought.

        Returns the nth argument (bound variable) passed to this
        FunctionDefinition. If the index 'n' is invalid, 'None' is returned.

        See also getNumArguments().

        ______________________________________________________________________
        Method variant with the following signature:

            getArgument(string name)

        Get the argument named 'name' to this FunctionDefinition.

        Parameter 'name' is the exact name (case-sensitive) of the sought-
        after argument.

        Returns the argument (bound variable) having the given name, or 'None'
        if no such argument exists.

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


    def getBody(self, *args):
        """
        getBody(FunctionDefinition self) -> ASTNode
        getBody(FunctionDefinition self) -> ASTNode


        Get the mathematical expression that is the body of this
        FunctionDefinition object.

        Returns the body of this FunctionDefinition as an Abstract Syntax
        Tree, or 'None' if no body is defined.

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


    def isSetBody(self):
        """
        isSetBody(FunctionDefinition self) -> bool


        Predicate returning 'True' if the body of this FunctionDefinition has
        set.

        Returns 'True' if the body of this FunctionDefinition is  set, 'False'
        otherwise.

        """
        return _libsbml.FunctionDefinition_isSetBody(self)


    def getNumArguments(self):
        """
        getNumArguments(FunctionDefinition self) -> unsigned int


        Get the number of arguments (bound variables) taken by this
        FunctionDefinition.

        Returns the number of arguments (bound variables) that must be passed
        to this FunctionDefinition.

        """
        return _libsbml.FunctionDefinition_getNumArguments(self)


    def getTypeCode(self):
        """
        getTypeCode(FunctionDefinition self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_FUNCTION_DEFINITION
        (default).

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.FunctionDefinition_getTypeCode(self)


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


        Returns the XML element name of this object, which for
        FunctionDefinition, is always ''functionDefinition'.'

        Returns the name of this element, i.e., ''functionDefinition'.'

        """
        return _libsbml.FunctionDefinition_getElementName(self)


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


        Predicate returning 'True' if all the required attributes for this
        FunctionDefinition object have been set.

        The required attributes for a FunctionDefinition object are:

        * 'id'

        Returns 'True' if the required attributes have been set, 'False'
        otherwise.

        """
        return _libsbml.FunctionDefinition_hasRequiredAttributes(self)


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


        Predicate returning 'True' if all the required elements for this
        FunctionDefinition object have been set.

        Note: The required elements for a FunctionDefinition object are:

        * 'math' inSBML Level 2 and Level 3 Version 1.   (In SBML Level 3
        Version 2+, it is no longer required.)

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

        """
        return _libsbml.FunctionDefinition_hasRequiredElements(self)


    def renameUnitSIdRefs(self, oldid, newid):
        """
        renameUnitSIdRefs(FunctionDefinition self, string oldid, string newid)


        Renames all the 'UnitSIdRef' attributes on this element.

        In SBML, unit definitions have identifiers of type UnitSId.  In SBML
        Level 3, an explicit data type called UnitSIdRef was introduced for
        attribute values that refer to UnitSId values; in previous Levels of
        SBML, this data type did not exist and attributes were simply
        described to as 'referring to a unit identifier', but the effective
        data type was the same as UnitSIdRef in Level 3.  These and other
        methods of libSBML refer to the type UnitSIdRef for all Levels of
        SBML, even if the corresponding SBML specification did not explicitly
        name the data type.

        This method works by looking at all unit identifier attribute values
        (including, if appropriate, inside mathematical formulas), comparing
        the unit identifiers to the value of 'oldid'.  If any matches are
        found, the matching identifiers are replaced with 'newid'.  The method
        does not descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.FunctionDefinition_renameUnitSIdRefs(self, oldid, newid)

FunctionDefinition_swigregister = _libsbml.FunctionDefinition_swigregister
FunctionDefinition_swigregister(FunctionDefinition)

class ListOfFunctionDefinitions(ListOf):
    """

    A list of FunctionDefinition objects.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, 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 __init__(self, *args):
        """
        __init__(ListOfFunctionDefinitions self, unsigned int level, unsigned int version) -> ListOfFunctionDefinitions
        __init__(ListOfFunctionDefinitions self, SBMLNamespaces sbmlns) -> ListOfFunctionDefinitions


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfFunctionDefinitions(SBMLNamespaces sbmlns)

        Creates a new ListOfFunctionDefinitions object.

        The object is constructed such that it is valid for the SBML Level and
        Version combination determined by the SBMLNamespaces object in
        'sbmlns'.

        Parameter 'sbmlns' is an SBMLNamespaces object that is used to
        determine the characteristics of the ListOfFunctionDefinitions object
        to be created.

        Throws SBMLConstructorException: Thrown if the given 'sbmlns' is
        inconsistent or incompatible with this object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfFunctionDefinitions(long level, long version)

        Creates a new ListOfFunctionDefinitions object.

        The object is constructed such that it is valid for the given SBML
        Level and Version combination.

        Parameter 'level' is the SBML Level.

        Parameter 'version' is the Version within the SBML Level.

        Throws SBMLConstructorException: Thrown if the given 'level' and
        'version' combination are invalid or if this object is incompatible
        with the given level and version.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        """
        this = _libsbml.new_ListOfFunctionDefinitions(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ListOfFunctionDefinitions self) -> ListOfFunctionDefinitions


        Creates and returns a deep copy of this ListOfFunctionDefinitions
        object.

        Returns the (deep) copy of this ListOfFunctionDefinitions object.

        """
        return _libsbml.ListOfFunctionDefinitions_clone(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfFunctionDefinitions self) -> int


        Returns the libSBML type code for the objects contained in this ListOf
        (i.e., FunctionDefinition objects, if the list is non-empty).

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for the objects contained in this ListOf:
        SBML_FUNCTION_DEFINITION (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfFunctionDefinitions_getItemTypeCode(self)


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


        Returns the XML element name of this object.

        For ListOfFunctionDefinitions, the XML element name is
        ''listOfFunctionDefinitions'.'

        Returns the name of this element, i.e., ''listOfFunctionDefinitions'.'

        """
        return _libsbml.ListOfFunctionDefinitions_getElementName(self)


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a FunctionDefinition from the ListOfFunctionDefinitions.

        Parameter 'n' is the index number of the FunctionDefinition to get.

        Returns the nth FunctionDefinition in this ListOfFunctionDefinitions.
        If the index 'n' is invalid, 'None' is returned.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a FunctionDefinition from the ListOfFunctionDefinitions based on
        its identifier.

        Parameter 'sid' is a string representing the identifier  of the
        FunctionDefinition to get.

        Returns FunctionDefinition in this ListOfFunctionDefinitions with the
        given 'sid' or 'None' if no such FunctionDefinition exists.

        See also get(), size().

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


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth item from this ListOfFunctionDefinitions items and
        returns a pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the item to remove.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        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 'sid', then
        'None' is returned.

        Parameter 'sid' is the identifier of the item to remove.

        Returns the item removed.  As mentioned above, the caller owns the
        returned item.

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

    __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_AVOGADRO = _libsbml.UNIT_KIND_AVOGADRO
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(uk1, uk2):
    """
    UnitKind_equals(UnitKind_t uk1, UnitKind_t uk2) -> int


    Tests for logical equality between two given UNIT_KIND_ code values.

    This function behaves exactly like C's == operator, except for the
    following two cases:

    * UNIT_KIND_LITER == UNIT_KIND_LITRE

    * UNIT_KIND_METER == UNIT_KIND_METRE In the two cases above, C
    equality comparison would yield '0' (false) (because each of the above
    is a distinct enumeration value), but this function returns 'True.'

    Parameter 'uk1' is a UNIT_KIND_ value. Parameter 'uk2' is a second
    UNIT_KIND_ value to compare to 'uk1'.

    Returns '1' (true) if 'uk1' is logically equivalent to 'uk2', '0'
    (false) otherwise.

    Note: For more information about the libSBML unit codes, please refer
    to the class documentation for Unit.

    """
    return _libsbml.UnitKind_equals(uk1, uk2)

def UnitKind_forName(name):
    """
    UnitKind_forName(char const * name) -> UnitKind_t


    Converts a text string naming a kind of unit to its corresponding
    libSBML UNIT_KIND_ constant/enumeration value.

    Parameter 'name' is a string, the name of a predefined base unit in
    SBML.

    Returns a value the set of UNIT_KIND_ codes defined in class libsbml,
    corresponding to the string 'name' (determined in a case-insensitive
    manner).

    Note: For more information about the libSBML unit codes, please refer
    to the class documentation for Unit.

    """
    return _libsbml.UnitKind_forName(name)

def UnitKind_toString(uk):
    """
    UnitKind_toString(UnitKind_t uk) -> char const *


    Converts a unit code to a text string equivalent.

    Parameter 'uk' is a value from the set of UNIT_KIND_ codes defined in
    the class libsbml

    Returns the name corresponding to the given unit code.

    Note: For more information about the libSBML unit codes, please refer
    to the class documentation for Unit.

    WARNING:

    The string returned is a static data value.  The caller does not own
    the returned string and is therefore not allowed to modify it.

    """
    return _libsbml.UnitKind_toString(uk)

def UnitKind_isValidUnitKindString(str, level, version):
    """
    UnitKind_isValidUnitKindString(char const * str, unsigned int level, unsigned int version) -> int


    Predicate for testing whether a given string corresponds to a
    predefined libSBML unit code.

    Parameter 'str' is a text string naming a base unit defined by SBML.
    Parameter 'level' is the Level of SBML. Parameter 'version' is the
    Version within the Level of SBML.

    Returns 1 (true) if string is the name of a valid UNIT_KIND_ value,
    '0' (false) otherwise.

    Note: For more information about the libSBML unit codes, please refer
    to the class documentation for Unit.

    """
    return _libsbml.UnitKind_isValidUnitKindString(str, level, version)
class Unit(SBase):
    """

    A single unit referenced in an SBML unit definition.

    The SBML unit definition facility uses two classes of objects,
    UnitDefinition and Unit.  The approach to defining units in SBML is
    compositional; for example, meter second^-2 is constructed by
    combining a Unit object representing meter with another Unit object
    representing second^-2. 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 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 must be one of the text strings listed below; this
    list corresponds to SBML Level 3:

       ampere         farad  joule     lux     radian     volt  
       avogadro       gram   katal     metre   second     watt  
       becquerel      gray   kelvin    mole    siemens    weber 
       candela        henry  kilogram  newton  sievert          
       coulomb        hertz  litre     ohm     steradian        
       dimensionless  item   lumen     pascal  tesla

    A few small differences exist between the Level 3 list of base units
    and the list defined in other Level/Version combinations of SBML.
    Specifically, Levels of SBML before Level 3 do not define 'avogadro;'
    conversely, Level 2 Version 1 defines 'Celsius,' and Level 1 defines
    'celsius,' 'meter,' and 'liter,' none of which are available in Level
    3.  In libSBML, each of the predefined base unit names is represented
    by an enumeration value whose name begins with the characters
    UNIT_KIND_, discussed in a separate section below.

    The attribute named 'exponent' on Unit represents an exponent on the
    unit.  In SBML Level 2, the attribute is optional and has a default
    value of '1' (one); in SBML Level 3, the attribute is mandatory and
    there is no default value.  A Unit also has an 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 'gram' and a 'scale' value of '-3' signifies
    10^-3 * gram, or milligrams.  In SBML Level 2, the attribute is
    optional and has a default value of '0' (zero), because 10^0 = 1; in
    SBML Level 3, the attribute is mandatory and has no default value.
    Lastly, the attribute named 'multiplier' can be used to multiply the
    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 'foot' as a measure of
    length in terms of a 'metre.'  The 'multiplier' attribute is optional
    in SBML Level 2, where it has a default value of '1' (one); in SBML
    Level 3, the attribute is mandatory and has no default value.

    Unit identification codes
    ......................................................................

    As discussed above, 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.

    In SBML Level 2 Versions before Version 3, there existed an
    enumeration of units called 'UnitKind.'  In Version 3, this
    enumeration was removed and the identifier class 'UnitSId' redefined
    to include the previous '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 UNIT_KIND_.  These constants are defined in the class
    libsbml.

    As a consequence of the fact that libSBML supports models in all
    Levels and Versions of SBML, libSBML's set of 'UNIT_KIND_' values is a
    union of all the possible base unit names defined in the different
    SBML specifications.  However, not every base unit is allowed in every
    Level+Version combination of SBML.  Note in particular the following
    exceptions:

    * The alternate spelling ''meter'' is included in addition to the
    official SI spelling ''metre'.'  This spelling is only permitted in
    SBML Level 1 models.

    * The alternate spelling ''liter'' is included in addition to the
    official SI spelling ''litre'.'  This spelling is only permitted in
    SBML Level 1 models.

    * The unit ''Celsius'' is included because of its presence in
    specifications of SBML prior to SBML Level 2 Version 2.

    * The unit 'avogadro' was introduced in SBML Level 3, and is only
    permitted for use in SBML Level 3 models. The table below lists the
    unit constants defined in libSBML, and their meanings.

      Enumerator              Meaning
      ---------               ---------
      UNIT_KIND_AMPERE        The ampere unit.
      UNIT_KIND_AVOGADRO      'dimensionless' multiplied by the value of Avogadro's constant.
      UNIT_KIND_BECQUEREL     The becquerel unit.
      UNIT_KIND_CANDELA       The candela unit.
      UNIT_KIND_CELSIUS       The Celsius unit. 
      UNIT_KIND_COULOMB       The coulomb unit.
      UNIT_KIND_DIMENSIONLESS A pseudo-unit indicating a dimensionless quantity.
      UNIT_KIND_FARAD         The farad unit.
      UNIT_KIND_GRAM          The gram unit.
      UNIT_KIND_GRAY          The gray unit.
      UNIT_KIND_HENRY         The henry unit.
      UNIT_KIND_HERTZ         The hertz unit.
      UNIT_KIND_ITEM          A pseudo-unit representing a single "thing".
      UNIT_KIND_JOULE         The joule unit.
      UNIT_KIND_KATAL         The katal unit.
      UNIT_KIND_KELVIN        The kelvin unit.
      UNIT_KIND_KILOGRAM      The kilogram unit.
      UNIT_KIND_LITER         Alternate spelling of litre.
      UNIT_KIND_LITRE         The litre unit.
      UNIT_KIND_LUMEN         The lumen unit.
      UNIT_KIND_LUX           The lux unit.
      UNIT_KIND_METER         Alternate spelling of metre.
      UNIT_KIND_METRE         The metre unit.
      UNIT_KIND_MOLE          The mole unit.
      UNIT_KIND_NEWTON        The newton unit.
      UNIT_KIND_OHM           The ohm unit.
      UNIT_KIND_PASCAL        The pascal unit.
      UNIT_KIND_RADIAN        The radian unit.
      UNIT_KIND_SECOND        The second unit.
      UNIT_KIND_SIEMENS       The siemens unit.
      UNIT_KIND_SIEVERT       The sievert unit.
      UNIT_KIND_STERADIAN     The steradian unit.
      UNIT_KIND_TESLA         The tesla unit.
      UNIT_KIND_VOLT          The volt unit.
      UNIT_KIND_WATT          The watt unit.
      UNIT_KIND_WEBER         The weber unit.
      UNIT_KIND_INVALID       Marker used by libSBML to indicate an invalid or unset unit.

    """

    __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__(Unit self, unsigned int level, unsigned int version) -> Unit
        __init__(Unit self, SBMLNamespaces sbmlns) -> Unit
        __init__(Unit self, Unit orig) -> Unit


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            Unit(SBMLNamespaces sbmlns)

        Creates a new Unit using the given SBMLNamespaces object 'sbmlns'.

        The SBMLNamespaces object encapsulates SBML Level/Version/namespaces
        information.  It is used to communicate the SBML Level, Version, and
        (in Level 3) packages used in addition to SBML Level 3 Core.  A common
        approach to using libSBML's SBMLNamespaces facilities is to create an
        SBMLNamespaces object somewhere in a program once, then hand that
        object as needed to object constructors that accept SBMLNamespaces as
        arguments.

        Parameter 'sbmlns' is an SBMLNamespaces object.

        Throws SBMLConstructorException: Thrown if the given 'sbmlns' is
        inconsistent or incompatible with this object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            Unit(long level, long version)

        Creates a new Unit using the given SBML 'level' and 'version' values.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        Unit.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this Unit.

        Throws SBMLConstructorException: Thrown if the given 'level' and
        'version' combination are invalid or if this object is incompatible
        with the given level and version.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            Unit(Unit orig)

        Copy constructor; creates a copy of this Unit.

        Parameter 'orig' is the object to copy.

        """
        this = _libsbml.new_Unit(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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


        Creates and returns a deep copy of this Unit object.

        Returns the (deep) copy of this Unit object.

        """
        return _libsbml.Unit_clone(self)


    def initDefaults(self):
        """
        initDefaults(Unit self)


        Initializes the fields of this Unit object to 'typical' default
        values.

        The SBML Unit component has slightly different aspects and default
        attribute values in different SBML Levels and Versions.  This method
        sets the values to certain common defaults, based mostly on what they
        are in SBML Level 2.  Specifically:

        * Sets attribute 'exponent' to '1'

        * Sets attribute 'scale' to '0'

        * Sets attribute 'multiplier' to '1.0' The 'kind' attribute is left
        unchanged.

        """
        return _libsbml.Unit_initDefaults(self)


    def getKind(self):
        """
        getKind(Unit self) -> UnitKind_t


        Returns the 'kind' of Unit this is.

        Returns the value of the 'kind' attribute of this Unit as a value from
        the set of constants whose names begin with UNIT_KIND_ defined in the
        class libsbml.

        """
        return _libsbml.Unit_getKind(self)


    def getExponent(self):
        """
        getExponent(Unit self) -> int


        Returns the value of the 'exponent' attribute of this unit.

        Returns the 'exponent' value of this Unit, as an integer.

        """
        return _libsbml.Unit_getExponent(self)


    def getExponentAsDouble(self):
        """
        getExponentAsDouble(Unit self) -> double


        Returns the value of the 'exponent' attribute of this unit.

        Returns the 'exponent' value of this Unit, as a double.

        """
        return _libsbml.Unit_getExponentAsDouble(self)


    def getScale(self):
        """
        getScale(Unit self) -> int


        Returns the value of the 'scale' attribute of this unit.

        Returns the 'scale' value of this Unit, as an integer.

        """
        return _libsbml.Unit_getScale(self)


    def getMultiplier(self):
        """
        getMultiplier(Unit self) -> double


        Returns the value of the 'multiplier' attribute of this Unit.

        Returns the 'multiplier' value of this Unit, as a double.

        """
        return _libsbml.Unit_getMultiplier(self)


    def getOffset(self):
        """
        getOffset(Unit self) -> double


        Returns the value of the 'offset' attribute of this Unit.

        Returns the 'offset' value of this Unit, as a double.

        WARNING:

        The 'offset' attribute is only available in SBML Level 2 Version 1.
        This attribute is not present in SBML Level 2 Version 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 2,
        but their use is strongly discouraged.

        """
        return _libsbml.Unit_getOffset(self)


    def isAmpere(self):
        """
        isAmpere(Unit self) -> bool


        Predicate for testing whether this Unit is of the kind 'ampere.'

        Returns 'True' if the kind of this Unit is 'ampere,' 'False'
        otherwise.

        """
        return _libsbml.Unit_isAmpere(self)


    def isAvogadro(self):
        """
        isAvogadro(Unit self) -> bool


        Predicate for testing whether this Unit is of the kind 'avogadro.'

        Returns 'True' if the kind of this Unit is 'avogadro,' 'False'
        otherwise.

        Note: The unit 'avogadro' was introduced in SBML Level 3, and is only
        permitted for use in SBML Level 3 models.

        """
        return _libsbml.Unit_isAvogadro(self)


    def isBecquerel(self):
        """
        isBecquerel(Unit self) -> bool


        Predicate for testing whether this Unit is of the kind 'becquerel'

        Returns 'True' if the kind of this Unit is 'becquerel,' 'False'
        otherwise.

        """
        return _libsbml.Unit_isBecquerel(self)


    def isCandela(self):
        """
        isCandela(Unit self) -> bool


        Predicate for testing whether this Unit is of the kind 'candela'

        Returns 'True' if the kind of this Unit is 'candela,' 'False'
        otherwise.

        """
        return _libsbml.Unit_isCandela(self)


    def isCelsius(self):
        """
        isCelsius(Unit self) -> bool


        Predicate for testing whether this Unit is of the kind 'Celsius'

        Returns 'True' if the kind of this Unit is 'Celsius,' 'False'
        otherwise.

        WARNING:

        The predefined unit 'Celsius' was removed from the list of predefined
        units in SBML Level 2 Version 2 at the same time that the 'offset'
        attribute was removed from Unit definitions.  LibSBML methods such as
        this one related to 'Celsius' are retained in order to support SBML
        Level 2 Version 1, but their use is strongly discouraged.

        """
        return _libsbml.Unit_isCelsius(self)


    def isCoulomb(self):
        """
        isCoulomb(Unit self) -> bool


        Predicate for testing whether this Unit is of the kind 'coulomb'

        Returns 'True' if the kind of this Unit is 'coulomb,' 'False'
        otherwise.

        """
        return _libsbml.Unit_isCoulomb(self)


    def isDimensionless(self):
        """
        isDimensionless(Unit self) -> bool


        Predicate for testing whether this Unit is of the kind
        'dimensionless.'

        Returns 'True' if the kind of this Unit is 'dimensionless,' 'False'
        otherwise.

        """
        return _libsbml.Unit_isDimensionless(self)


    def isFarad(self):
        """
        isFarad(Unit self) -> bool


        Predicate for testing whether this Unit is of the kind 'farad'

        Returns 'True' if the kind of this Unit is 'farad,' 'False' otherwise.

        """
        return _libsbml.Unit_isFarad(self)


    def isGram(self):
        """
        isGram(Unit self) -> bool


        Predicate for testing whether this Unit is of the kind 'gram'

        Returns 'True' if the kind of this Unit is 'gram,' 'False' otherwise.

        """
        return _libsbml.Unit_isGram(self)


    def isGray(self):
        """
        isGray(Unit self) -> bool


        Predicate for testing whether this Unit is of the kind 'gray'

        Returns 'True' if the kind of this Unit is 'gray,' 'False' otherwise.

        """
        return _libsbml.Unit_isGray(self)


    def isHenry(self):
        """
        isHenry(Unit self) -> bool


        Predicate for testing whether this Unit is of the kind 'henry'

        Returns 'True' if the kind of this Unit is 'henry,' 'False' otherwise.

        """
        return _libsbml.Unit_isHenry(self)


    def isHertz(self):
        """
        isHertz(Unit self) -> bool


        Predicate for testing whether this Unit is of the kind 'hertz'

        Returns 'True' if the kind of this Unit is 'hertz,' 'False' otherwise.

        """
        return _libsbml.Unit_isHertz(self)


    def isItem(self):
        """
        isItem(Unit self) -> bool


        Predicate for testing whether this Unit is of the kind 'item'

        Returns 'True' if the kind of this Unit is 'item,' 'False' otherwise.

        """
        return _libsbml.Unit_isItem(self)


    def isJoule(self):
        """
        isJoule(Unit self) -> bool


        Predicate for testing whether this Unit is of the kind 'joule'

        Returns 'True' if the kind of this Unit is 'joule,' 'False' otherwise.

        """
        return _libsbml.Unit_isJoule(self)


    def isKatal(self):
        """
        isKatal(Unit self) -> bool


        Predicate for testing whether this Unit is of the kind 'katal'

        Returns 'True' if the kind of this Unit is 'katal,' 'False' otherwise.

        """
        return _libsbml.Unit_isKatal(self)


    def isKelvin(self):
        """
        isKelvin(Unit self) -> bool


        Predicate for testing whether this Unit is of the kind 'kelvin'

        Returns 'True' if the kind of this Unit is 'kelvin,' 'False'
        otherwise.

        """
        return _libsbml.Unit_isKelvin(self)


    def isKilogram(self):
        """
        isKilogram(Unit self) -> bool


        Predicate for testing whether this Unit is of the kind 'kilogram'

        Returns 'True' if the kind of this Unit is 'kilogram,' 'False'
        otherwise.

        """
        return _libsbml.Unit_isKilogram(self)


    def isLitre(self):
        """
        isLitre(Unit self) -> bool


        Predicate for testing whether this Unit is of the kind 'litre'

        Returns 'True' if the kind of this Unit is 'litre' or 'liter', 'False'
        otherwise.

        """
        return _libsbml.Unit_isLitre(self)


    def isLumen(self):
        """
        isLumen(Unit self) -> bool


        Predicate for testing whether this Unit is of the kind 'lumen'

        Returns 'True' if the kind of this Unit is 'lumen,' 'False' otherwise.

        """
        return _libsbml.Unit_isLumen(self)


    def isLux(self):
        """
        isLux(Unit self) -> bool


        Predicate for testing whether this Unit is of the kind 'lux'

        Returns 'True' if the kind of this Unit is 'lux,' 'False' otherwise.

        """
        return _libsbml.Unit_isLux(self)


    def isMetre(self):
        """
        isMetre(Unit self) -> bool


        Predicate for testing whether this Unit is of the kind 'metre'

        Returns 'True' if the kind of this Unit is 'metre' or 'meter', 'False'
        otherwise.

        """
        return _libsbml.Unit_isMetre(self)


    def isMole(self):
        """
        isMole(Unit self) -> bool


        Predicate for testing whether this Unit is of the kind 'mole'

        Returns 'True' if the kind of this Unit is 'mole,' 'False' otherwise.

        """
        return _libsbml.Unit_isMole(self)


    def isNewton(self):
        """
        isNewton(Unit self) -> bool


        Predicate for testing whether this Unit is of the kind 'newton'

        Returns 'True' if the kind of this Unit is 'newton,' 'False'
        otherwise.

        """
        return _libsbml.Unit_isNewton(self)


    def isOhm(self):
        """
        isOhm(Unit self) -> bool


        Predicate for testing whether this Unit is of the kind 'ohm'

        Returns 'True' if the kind of this Unit is 'ohm,' 'False' otherwise.

        """
        return _libsbml.Unit_isOhm(self)


    def isPascal(self):
        """
        isPascal(Unit self) -> bool


        Predicate for testing whether this Unit is of the kind 'pascal'

        Returns 'True' if the kind of this Unit is 'pascal,' 'False'
        otherwise.

        """
        return _libsbml.Unit_isPascal(self)


    def isRadian(self):
        """
        isRadian(Unit self) -> bool


        Predicate for testing whether this Unit is of the kind 'radian'

        Returns 'True' if the kind of this Unit is 'radian,' 'False'
        otherwise.

        """
        return _libsbml.Unit_isRadian(self)


    def isSecond(self):
        """
        isSecond(Unit self) -> bool


        Predicate for testing whether this Unit is of the kind 'second'

        Returns 'True' if the kind of this Unit is 'second,' 'False'
        otherwise.

        """
        return _libsbml.Unit_isSecond(self)


    def isSiemens(self):
        """
        isSiemens(Unit self) -> bool


        Predicate for testing whether this Unit is of the kind 'siemens'

        Returns 'True' if the kind of this Unit is 'siemens,' 'False'
        otherwise.

        """
        return _libsbml.Unit_isSiemens(self)


    def isSievert(self):
        """
        isSievert(Unit self) -> bool


        Predicate for testing whether this Unit is of the kind 'sievert'

        Returns 'True' if the kind of this Unit is 'sievert,' 'False'
        otherwise.

        """
        return _libsbml.Unit_isSievert(self)


    def isSteradian(self):
        """
        isSteradian(Unit self) -> bool


        Predicate for testing whether this Unit is of the kind 'steradian'

        Returns 'True' if the kind of this Unit is 'steradian,' 'False'
        otherwise.

        """
        return _libsbml.Unit_isSteradian(self)


    def isTesla(self):
        """
        isTesla(Unit self) -> bool


        Predicate for testing whether this Unit is of the kind 'tesla'

        Returns 'True' if the kind of this Unit is 'tesla,' 'False' otherwise.

        """
        return _libsbml.Unit_isTesla(self)


    def isVolt(self):
        """
        isVolt(Unit self) -> bool


        Predicate for testing whether this Unit is of the kind 'volt'

        Returns 'True' if the kind of this Unit is 'volt,' 'False' otherwise.

        """
        return _libsbml.Unit_isVolt(self)


    def isWatt(self):
        """
        isWatt(Unit self) -> bool


        Predicate for testing whether this Unit is of the kind 'watt'

        Returns 'True' if the kind of this Unit is 'watt,' 'False' otherwise.

        """
        return _libsbml.Unit_isWatt(self)


    def isWeber(self):
        """
        isWeber(Unit self) -> bool


        Predicate for testing whether this Unit is of the kind 'weber'

        Returns 'True' if the kind of this Unit is 'weber,' 'False' otherwise.

        """
        return _libsbml.Unit_isWeber(self)


    def isSetKind(self):
        """
        isSetKind(Unit self) -> bool


        Predicate to test whether the 'kind' attribute of this Unit is set.

        Returns 'True' if the 'kind' attribute of this Unit is set, 'False'
        otherwise.

        """
        return _libsbml.Unit_isSetKind(self)


    def isSetExponent(self):
        """
        isSetExponent(Unit self) -> bool


        Predicate to test whether the 'exponent' attribute of this Unit  is
        set.

        Returns 'True' if the 'exponent' attribute of this Unit is set,
        'False' otherwise.

        """
        return _libsbml.Unit_isSetExponent(self)


    def isSetScale(self):
        """
        isSetScale(Unit self) -> bool


        Predicate to test whether the 'scale' attribute of this Unit  is set.

        Returns 'True' if the 'scale' attribute of this Unit is set,  'False'
        otherwise.

        """
        return _libsbml.Unit_isSetScale(self)


    def isSetMultiplier(self):
        """
        isSetMultiplier(Unit self) -> bool


        Predicate to test whether the 'multiplier' attribute of this Unit  is
        set.

        Returns 'True' if the 'multiplier' attribute of this Unit is set,
        'False' otherwise.

        """
        return _libsbml.Unit_isSetMultiplier(self)


    def isSetOffset(self):
        """
        isSetOffset(Unit self) -> bool


        Predicate to test whether the 'offset' attribute of this Unit  is set.

        Returns 'True' if the 'offset' attribute of this Unit is set,  'False'
        otherwise.

        WARNING:

        The 'offset' attribute is only available in SBML Level 2 Version 1.
        This attribute is not present in SBML Level 2 Version 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 2,
        but their use is strongly discouraged.

        """
        return _libsbml.Unit_isSetOffset(self)


    def setKind(self, kind):
        """
        setKind(Unit self, UnitKind_t kind) -> int


        Sets the 'kind' attribute value of this Unit.

        Parameter 'kind' is a unit identifier chosen from the set of constants
        whose names begin with UNIT_KIND_ in libsbml.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Unit_setKind(self, kind)


    def setExponent(self, *args):
        """
        setExponent(Unit self, int value) -> int
        setExponent(Unit self, double value) -> int


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            setExponent(int value)

        Sets the 'exponent' attribute value of this Unit.

        Parameter 'value' is the integer to which the attribute 'exponent'
        should be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        ______________________________________________________________________
        Method variant with the following signature:

            setExponent(double value)

        Sets the 'exponent' attribute value of this Unit.

        Parameter 'value' is the double to which the attribute 'exponent'
        should be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

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


    def setScale(self, value):
        """
        setScale(Unit self, int value) -> int


        Sets the 'scale' attribute value of this Unit.

        Parameter 'value' is the integer to which the attribute 'scale' should
        be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.Unit_setScale(self, value)


    def setMultiplier(self, value):
        """
        setMultiplier(Unit self, double value) -> int


        Sets the 'multipler' attribute value of this Unit.

        Parameter 'value' is the floating-point value to which the attribute
        'multiplier' should be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        """
        return _libsbml.Unit_setMultiplier(self, value)


    def setOffset(self, value):
        """
        setOffset(Unit self, double value) -> int


        Sets the 'offset' attribute value of this Unit.

        Parameter 'value' is the floating point value to which the attribute
        'offset' should set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        WARNING:

        The 'offset' attribute is only available in SBML Level 2 Version 1.
        This attribute is not present in SBML Level 2 Version 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 2,
        but their use is strongly discouraged.

        """
        return _libsbml.Unit_setOffset(self, value)


    def unsetKind(self):
        """
        unsetKind(Unit self) -> int


        Unsets the 'kind' attribute value of this Unit.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Unit_unsetKind(self)


    def unsetExponent(self):
        """
        unsetExponent(Unit self) -> int


        Unsets the 'exponent' attribute value of this Unit.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Unit_unsetExponent(self)


    def unsetScale(self):
        """
        unsetScale(Unit self) -> int


        Unsets the 'scale' attribute value of this Unit.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.Unit_unsetScale(self)


    def unsetMultiplier(self):
        """
        unsetMultiplier(Unit self) -> int


        Unsets the 'multipler' attribute value of this Unit.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        """
        return _libsbml.Unit_unsetMultiplier(self)


    def unsetOffset(self):
        """
        unsetOffset(Unit self) -> int


        Unsets the 'offset' attribute value of this Unit.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        WARNING:

        The 'offset' attribute is only available in SBML Level 2 Version 1.
        This attribute is not present in SBML Level 2 Version 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 2,
        but their use is strongly discouraged.

        """
        return _libsbml.Unit_unsetOffset(self)


    def getTypeCode(self):
        """
        getTypeCode(Unit self) -> int


        Returns the libSBML type code of this object instance.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_UNIT (default).

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getPackageName(), getElementName().

        """
        return _libsbml.Unit_getTypeCode(self)


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


        Returns the XML element name of this object, which for Unit, is always
        ''unit'.'

        Returns the name of this element, i.e., ''unit'.'

        """
        return _libsbml.Unit_getElementName(self)


    def isBuiltIn(name, level):
        """
        isBuiltIn(string name, unsigned int level) -> bool


        Predicate to test whether a given string is the name of a built-in
        SBML unit, depending on the SBML level, since new predefined units
        were added between level 2 versions 1 and 2, and then all predefined
        units were removed again in SBML Level 3.

        Parameter 'name' is a string to be tested against the built-in unit
        names. Parameter 'level' is the level of SBML one is checking.

        Returns 'True' if 'name' is one of ''substance',' ''volume',' or
        ''time'' and the 'level' is '1;' or if 'name' is one of ''substance','
        ''volume',' ''area',' ''length',' or ''time'' and the 'level' is '2;'
        'False' otherwise (including all values when 'level' is '3).'

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.Unit_isBuiltIn(name, level)

    isBuiltIn = staticmethod(isBuiltIn)

    def isUnitKind(name, level, version):
        """
        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 ''gram'' or ''mole').'

        This method exists because prior to SBML Level 2 Version 3, an
        enumeration called 'UnitKind' was defined by SBML.  This enumeration
        was removed in SBML Level 2 Version 3 and its values were folded into
        the space of values of a type called 'UnitSId.'  This method therefore
        has less significance in SBML Level 2 Version 3 and Level 2 Version 4,
        but remains for backward compatibility and support for reading models
        in older Versions of Level 2.

        Parameter 'name' is a string to be tested.

        Parameter 'level' is a long integer representing the SBML
        specification Level.

        Parameter 'version' is a long integer representing the SBML
        specification Version.

        Returns 'True' if name is a valid SBML UnitKind, 'False' otherwise.

        Note: The allowed unit names differ between SBML Levels 1 and 2 and
        again slightly between Level 2 Versions 1 and 2.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.Unit_isUnitKind(name, level, version)

    isUnitKind = staticmethod(isUnitKind)

    def areIdentical(unit1, unit2):
        """
        areIdentical(Unit unit1, Unit unit2) -> bool


        Predicate returning 'True' if two Unit objects are identical.

        Two Unit objects are considered to be identical if they match in all
        attributes.  (Contrast this to the method areEquivalent(), which
        compares Unit objects only with respect to certain attributes.)

        Parameter 'unit1' is the first Unit object to compare. Parameter
        'unit2' is the second Unit object to compare.

        Returns 'True' if all the attributes of unit1 are identical to the
        attributes of unit2, 'False' otherwise.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        See also Unit.areEquivalent() .

        """
        return _libsbml.Unit_areIdentical(unit1, unit2)

    areIdentical = staticmethod(areIdentical)

    def areEquivalent(unit1, unit2):
        """
        areEquivalent(Unit unit1, Unit unit2) -> bool


        Predicate returning 'True' if  Unit objects are equivalent.

        Two Unit objects are considered to be equivalent either if (1) both
        have a 'kind' attribute value of 'dimensionless,' or (2) their 'kind',
        'exponent' and (for SBML Level 2 Version 1) 'offset' attribute values
        are equal. (Contrast this to the method areIdentical(), which compares
        Unit objects with respect to all attributes, not just the 'kind' and
        'exponent'.)

        Parameter 'unit1' is the first Unit object to compare. Parameter
        'unit2' is the second Unit object to compare.

        Returns 'True' if the 'kind' and 'exponent' attributes of unit1 are
        identical to the kind and exponent attributes of unit2, or if the kind
        attributes of both are 'dimensionless;' 'False' otherwise.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        See also Unit.areIdentical() .

        """
        return _libsbml.Unit_areEquivalent(unit1, unit2)

    areEquivalent = staticmethod(areEquivalent)

    def removeScale(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=
        ''metre'' multiplier=''1'' scale=''-3'' exponent=''1'.' It can also be
        expressed as a Unit with kind=''metre'' multiplier='0.001' scale=''0''
        exponent=''1'.'

        Parameter 'unit' is the Unit object to manipulate.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        See also Unit.convertToSI() , Unit.merge() .

        """
        return _libsbml.Unit_removeScale(unit)

    removeScale = staticmethod(removeScale)

    def merge(unit1, unit2):
        """
        merge(Unit unit1, Unit unit2)


        Merges two Unit objects with the same 'kind' attribute value into a
        single Unit.

        For example, the following,

           <unit kind='metre' exponent='2'/>
           <unit kind='metre' exponent='1'/>

        would be merged to become

           <unit kind='metre' exponent='3'/>

        Parameter 'unit1' is the first Unit object; the result of the
        operation is left as a new version of this unit, modified in-place.
        Not modified if the two units have different kinds.

        Parameter 'unit2' is the second Unit object to merge with the first.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        See also Unit.convertToSI() , Unit.removeScale() .

        """
        return _libsbml.Unit_merge(unit1, unit2)

    merge = staticmethod(merge)

    def convertToSI(unit):
        """
        convertToSI(Unit unit) -> UnitDefinition


        Returns a UnitDefinition object containing the given 'unit' converted
        to the appropriate SI unit.

        This method exists because some units can be expressed in terms of
        others when the same physical dimension is involved.  For example, one
        hertz is identical to 1 sec^-1, one litre is equivalent to 1 cubic
        decametre, and so on.

        Parameter 'unit' is the Unit object to convert to SI.

        Returns a UnitDefinition object containing the SI unit.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        See also Unit.merge() .

        """
        return _libsbml.Unit_convertToSI(unit)

    convertToSI = staticmethod(convertToSI)

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


        Predicate returning 'True' if all the required attributes for this
        Unit object have been set.

        The required attributes for a Unit object are:

        * 'kind'

        * 'exponent' (required in SBML Level 3; optional in Level 2)

        * 'multiplier' (required in SBML Level 3; optional in Level 2)

        * 'scale' (required in SBML Level 3; optional in Level 2)

        Returns 'True' if the required attributes have been set, 'False'
        otherwise.

        """
        return _libsbml.Unit_hasRequiredAttributes(self)


    def setExponentUnitChecking(self, value):
        """
        setExponentUnitChecking(Unit self, double value)


        Internal implementation method.

        """
        return _libsbml.Unit_setExponentUnitChecking(self, value)


    def getExponentUnitChecking(self, *args):
        """
        getExponentUnitChecking(Unit self) -> double
        getExponentUnitChecking(Unit self) -> double


        Internal implementation method.

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


    def isUnitChecking(self, *args):
        """
        isUnitChecking(Unit self) -> bool
        isUnitChecking(Unit self) -> bool


        Internal implementation method.

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

Unit_swigregister = _libsbml.Unit_swigregister
Unit_swigregister(Unit)

def Unit_isBuiltIn(name, level):
    """
    Unit_isBuiltIn(string name, unsigned int level) -> bool


    Predicate to test whether a given string is the name of a built-in
    SBML unit, depending on the SBML level, since new predefined units
    were added between level 2 versions 1 and 2, and then all predefined
    units were removed again in SBML Level 3.

    Parameter 'name' is a string to be tested against the built-in unit
    names. Parameter 'level' is the level of SBML one is checking.

    Returns 'True' if 'name' is one of ''substance',' ''volume',' or
    ''time'' and the 'level' is '1;' or if 'name' is one of ''substance','
    ''volume',' ''area',' ''length',' or ''time'' and the 'level' is '2;'
    'False' otherwise (including all values when 'level' is '3).'

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.Unit_isBuiltIn(name, level)

def Unit_isUnitKind(name, level, version):
    """
    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 ''gram'' or ''mole').'

    This method exists because prior to SBML Level 2 Version 3, an
    enumeration called 'UnitKind' was defined by SBML.  This enumeration
    was removed in SBML Level 2 Version 3 and its values were folded into
    the space of values of a type called 'UnitSId.'  This method therefore
    has less significance in SBML Level 2 Version 3 and Level 2 Version 4,
    but remains for backward compatibility and support for reading models
    in older Versions of Level 2.

    Parameter 'name' is a string to be tested.

    Parameter 'level' is a long integer representing the SBML
    specification Level.

    Parameter 'version' is a long integer representing the SBML
    specification Version.

    Returns 'True' if name is a valid SBML UnitKind, 'False' otherwise.

    Note: The allowed unit names differ between SBML Levels 1 and 2 and
    again slightly between Level 2 Versions 1 and 2.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.Unit_isUnitKind(name, level, version)

def Unit_areIdentical(unit1, unit2):
    """
    Unit_areIdentical(Unit unit1, Unit unit2) -> bool


    Predicate returning 'True' if two Unit objects are identical.

    Two Unit objects are considered to be identical if they match in all
    attributes.  (Contrast this to the method areEquivalent(), which
    compares Unit objects only with respect to certain attributes.)

    Parameter 'unit1' is the first Unit object to compare. Parameter
    'unit2' is the second Unit object to compare.

    Returns 'True' if all the attributes of unit1 are identical to the
    attributes of unit2, 'False' otherwise.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    See also Unit.areEquivalent() .

    """
    return _libsbml.Unit_areIdentical(unit1, unit2)

def Unit_areEquivalent(unit1, unit2):
    """
    Unit_areEquivalent(Unit unit1, Unit unit2) -> bool


    Predicate returning 'True' if  Unit objects are equivalent.

    Two Unit objects are considered to be equivalent either if (1) both
    have a 'kind' attribute value of 'dimensionless,' or (2) their 'kind',
    'exponent' and (for SBML Level 2 Version 1) 'offset' attribute values
    are equal. (Contrast this to the method areIdentical(), which compares
    Unit objects with respect to all attributes, not just the 'kind' and
    'exponent'.)

    Parameter 'unit1' is the first Unit object to compare. Parameter
    'unit2' is the second Unit object to compare.

    Returns 'True' if the 'kind' and 'exponent' attributes of unit1 are
    identical to the kind and exponent attributes of unit2, or if the kind
    attributes of both are 'dimensionless;' 'False' otherwise.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    See also Unit.areIdentical() .

    """
    return _libsbml.Unit_areEquivalent(unit1, unit2)

def Unit_removeScale(unit):
    """
    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=
    ''metre'' multiplier=''1'' scale=''-3'' exponent=''1'.' It can also be
    expressed as a Unit with kind=''metre'' multiplier='0.001' scale=''0''
    exponent=''1'.'

    Parameter 'unit' is the Unit object to manipulate.

    Returns integer value indicating success/failure of the function.
    This particular function only does one thing irrespective of user
    input or  object state, and thus will only return a single value:

    * LIBSBML_OPERATION_SUCCESS

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    See also Unit.convertToSI() , Unit.merge() .

    """
    return _libsbml.Unit_removeScale(unit)

def Unit_merge(unit1, unit2):
    """
    Unit_merge(Unit unit1, Unit unit2)


    Merges two Unit objects with the same 'kind' attribute value into a
    single Unit.

    For example, the following,

       <unit kind='metre' exponent='2'/>
       <unit kind='metre' exponent='1'/>

    would be merged to become

       <unit kind='metre' exponent='3'/>

    Parameter 'unit1' is the first Unit object; the result of the
    operation is left as a new version of this unit, modified in-place.
    Not modified if the two units have different kinds.

    Parameter 'unit2' is the second Unit object to merge with the first.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    See also Unit.convertToSI() , Unit.removeScale() .

    """
    return _libsbml.Unit_merge(unit1, unit2)

def Unit_convertToSI(unit):
    """
    Unit_convertToSI(Unit unit) -> UnitDefinition


    Returns a UnitDefinition object containing the given 'unit' converted
    to the appropriate SI unit.

    This method exists because some units can be expressed in terms of
    others when the same physical dimension is involved.  For example, one
    hertz is identical to 1 sec^-1, one litre is equivalent to 1 cubic
    decametre, and so on.

    Parameter 'unit' is the Unit object to convert to SI.

    Returns a UnitDefinition object containing the SI unit.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    See also Unit.merge() .

    """
    return _libsbml.Unit_convertToSI(unit)

class ListOfUnits(ListOf):
    """

    A list of Unit objects.

    ListOfUnits is entirely contained within UnitDefinition.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    """

    __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 __init__(self, *args):
        """
        __init__(ListOfUnits self, unsigned int level, unsigned int version) -> ListOfUnits
        __init__(ListOfUnits self, SBMLNamespaces sbmlns) -> ListOfUnits


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfUnits(SBMLNamespaces sbmlns)

        Creates a new ListOfUnits object.

        The object is constructed such that it is valid for the SBML Level and
        Version combination determined by the SBMLNamespaces object in
        'sbmlns'.

        Parameter 'sbmlns' is an SBMLNamespaces object that is used to
        determine the characteristics of the ListOfUnits object to be created.

        Throws SBMLConstructorException: Thrown if the given 'sbmlns' is
        inconsistent or incompatible with this object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfUnits(long level, long version)

        Creates a new ListOfUnits object.

        The object is constructed such that it is valid for the given SBML
        Level and Version combination.

        Parameter 'level' is the SBML Level.

        Parameter 'version' is the Version within the SBML Level.

        Throws SBMLConstructorException: Thrown if the given 'level' and
        'version' combination are invalid or if this object is incompatible
        with the given level and version.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        """
        this = _libsbml.new_ListOfUnits(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ListOfUnits self) -> ListOfUnits


        Creates and returns a deep copy of this ListOfUnits object.

        Returns the (deep) copy of this ListOfUnits object.

        """
        return _libsbml.ListOfUnits_clone(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfUnits self) -> int


        Returns the libSBML type code for the objects contained in this ListOf
        (i.e., Unit objects, if the list is non-empty).

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for objects contained in this list:
        SBML_UNIT (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfUnits_getItemTypeCode(self)


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


        Returns the XML element name of this object.

        For ListOfUnits, the XML element name is ''listOfUnits'.'

        Returns the name of this element, i.e., ''listOfUnits'.'

        """
        return _libsbml.ListOfUnits_getElementName(self)


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


        Get a Unit from the ListOfUnits.

        Parameter 'n' is the index number of the Unit to get.

        Returns the nth Unit in this ListOfUnits. If the index 'n' is invalid,
        'None' is returned.

        See also size().

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


    def remove(self, n):
        """
        remove(ListOfUnits 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.

        Parameter 'n' is the index of the item to remove.

        See also size().

        """
        return _libsbml.ListOfUnits_remove(self, n)

    __swig_destroy__ = _libsbml.delete_ListOfUnits
    __del__ = lambda self: None
ListOfUnits_swigregister = _libsbml.ListOfUnits_swigregister
ListOfUnits_swigregister(ListOfUnits)

class UnitDefinition(SBase):
    """

    A definition of a unit used in an SBML model.

    Units of measurement may be supplied in a number of contexts in an
    SBML model.  The SBML unit definition facility uses two classes of
    objects, UnitDefinition and Unit.  The approach to defining units in
    SBML is compositional; for example, meter second^-2 is constructed by
    combining a Unit object representing meter with another Unit object
    representing second^-2. 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.

    Two points are worth discussing in the context of SBML units.  First,
    unit declarations in SBML models are optional.  The consequence of
    this is that a model must be numerically self-consistent independently
    of unit declarations, for the benefit of software tools that cannot
    interpret or manipulate units.  Unit declarations in SBML are thus
    more akin to a type of annotation; they can indicate intentions, and
    can be used by model readers for checking the consistency of the
    model, labeling simulation output, etc., but any transformations of
    values implied by different units must be incorporated explicitly into
    a model.

    Second, the vast majority of situations that require new SBML unit
    definitions involve simple multiplicative combinations of base units
    and factors.  An example is moles per litre per second.  What
    distinguishes these sorts of 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 to simplify implementation of unit support for
    the most common cases in systems biology.  The cost of this
    simplification is to require units with offsets to be handled
    explicitly by the modeler.

    Summary of the UnitDefinition construct
    ======================================================================

    UnitDefinition 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.  Please see the next
    section for information about the values permitted for 'id'.

    A UnitDefinition may contain exactly one ListOfUnits, and this list
    may contain one or more Unit definitions; see the definitions of these
    other object classes for more information about them.  In SBML  Level
    2 and SBML Level 3 Version 1, if the ListOfUnits was present, it must
    have one or more Unit definitions.  In SBML Level 3 Version 2, this
    restriction was relaxed, and  a ListOfUnits was allowed to be empty.
    In either case, if a UnitDefinition had no child Unit elements, the
    unit was considered to be undefined.

    The following example illustrates a complete unit definition (when
    written in XML) when all the pieces are combined together.  This
    defines 'mmls' to be millimoles per litre per second.

       <listOfUnitDefinitions>
           <unitDefinition id='mmls'>
               <listOfUnits>
                   <unit kind='mole'   scale='-3'/>
                   <unit kind='litre'  exponent='-1'/>
                   <unit kind='second' exponent='-1'/>
               </listOfUnits>
           </unitDefinition>
       </listOfUnitDefinitions>

    Special considerations for Unit object identifiers
    ======================================================================

    The attribute 'id' in UnitDefinition cannot be given simply any value,
    and the precise details of the values permitted differ slightly
    between Levels of SBML:

    * The 'id' of a UnitDefinition must not contain a value from the list
    of SBML's predefined base unit names (i.e., the strings 'gram,'
    'litre,' etc.).  In SBML Level 3, this list consists of the following:

       ampere         farad  joule     lux     radian     volt  
       avogadro       gram   katal     metre   second     watt  
       becquerel      gray   kelvin    mole    siemens    weber 
       candela        henry  kilogram  newton  sievert          
       coulomb        hertz  litre     ohm     steradian        
       dimensionless  item   lumen     pascal  tesla

    This list of predefined base units is nearly identical in SBML Level
    2 Version 4, the exception being that Level 2 does not define
    'avogadro.'  SBML Level 2 Version 1 (and only this Level+Version
    combination) provides an additional predefined unit name, 'Celsius,'
    not available in Level 3.  Finally, SBML Level 1 Versions 2-3 provide
    two more additional predefined unit names, 'meter' and 'liter.'  This
    is explained in somewhat greater detail in the description of the Unit
    class.

    * In SBML Level 2 (all Versions), there is an additional set of
    reserved identifiers: 'substance,' 'volume,' 'area,' 'length,' and
    '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 special unit
    names in SBML Level 2 is given in the table below:

      +------------+-------------------------------------------+---------------+
      | Identifier | Possible scalable units                   | Default units |
      +------------+-------------------------------------------+---------------+
      | substance  | mole, item, gram, kilogram, dimensionless | mole          |
      | volume     | litre, cubic metre, dimensionless         | litre         |
      | area       | square metre, dimensionless               | square metre  |
      | length     | metre, dimensionless                      | metre         |
      | time       | second, dimensionless                     | second        |
      +------------+-------------------------------------------+---------------+

    Also, SBML Level 2 imposes two limitations on redefining the
    predefined unit 'substance,' 'volume,' 'area,' 'length,' and '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.

    The special unit names 'substance,' 'volume,' 'area,' 'length,' and
    'time' are not defined by SBML Level 3, which uses a different
    approach to setting model-wide inherited units.

    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 moles per litre per second.
    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 2 Version 2, Unit no longer has the attribute called
    'offset' introduced in SBML Level 2 Version 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 2 Version 2, a
    consensus among SBML developers emerged that a fully generalized unit
    scheme is so confusing and complicated that it actually impedes
    interoperability. SBML Level 2 Version 2, Version 3 and Version 4
    acknowledge this reality by reducing and simplifying the unit system,
    specifically by removing the 'offset' attribute on Unit and '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:

    * Handling Celsius.  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_ kelvin = T_Celsius +
    273.15.  In every mathematical formula of the model where a quantity
    (call it x) in degrees Celsius appears, replace x with x_k+ 273.15,
    where x_k is now in kelvin.  An alternative approach would  be to use
    a FunctionDefinition object 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.

    * Other units requiring offsets.  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:

       <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>

    * 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.

    * Still another approach is to rewrite the mathematical formulas of a
    model to directly incorporate the conversion formula wherever the
    original quantity appeared. Please consult the SBML specifications for
    more information about this and other issues involving units.

    """

    __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__(UnitDefinition self, unsigned int level, unsigned int version) -> UnitDefinition
        __init__(UnitDefinition self, SBMLNamespaces sbmlns) -> UnitDefinition
        __init__(UnitDefinition self, UnitDefinition orig) -> UnitDefinition


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            UnitDefinition(SBMLNamespaces sbmlns)

        Creates a new UnitDefinition using the given SBMLNamespaces object
        'sbmlns'.

        The SBMLNamespaces object encapsulates SBML Level/Version/namespaces
        information.  It is used to communicate the SBML Level, Version, and
        (in Level 3) packages used in addition to SBML Level 3 Core.  A common
        approach to using libSBML's SBMLNamespaces facilities is to create an
        SBMLNamespaces object somewhere in a program once, then hand that
        object as needed to object constructors that accept SBMLNamespaces as
        arguments.

        Parameter 'sbmlns' is an SBMLNamespaces object.

        Throws SBMLConstructorException: Thrown if the given 'sbmlns' is
        inconsistent or incompatible with this object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            UnitDefinition(long level, long version)

        Creates a new UnitDefinition using the given SBML 'level' and
        'version' values.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        UnitDefinition.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this UnitDefinition.

        Throws SBMLConstructorException: Thrown if the given 'level' and
        'version' combination are invalid or if this object is incompatible
        with the given level and version.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            UnitDefinition(UnitDefinition orig)

        Copy constructor; creates a copy of this UnitDefinition.

        Parameter 'orig' is the object to copy.

        """
        this = _libsbml.new_UnitDefinition(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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


        Creates and returns a deep copy of this UnitDefinition object.

        Returns the (deep) copy of this UnitDefinition object.

        """
        return _libsbml.UnitDefinition_clone(self)


    def getElementBySId(self, id):
        """
        getElementBySId(UnitDefinition self, string id) -> SBase


        Returns the first child element found that has the given 'id' in the
        model-wide SId namespace, or 'None' if no such object is found.

        Parameter 'id' is string representing the id of the object to find.

        Returns pointer to the first element found with the given 'id'.

        """
        return _libsbml.UnitDefinition_getElementBySId(self, id)


    def getElementByMetaId(self, metaid):
        """
        getElementByMetaId(UnitDefinition self, string metaid) -> SBase


        Returns the first child element it can find with the given 'metaid',
        or 'None' if no such object is found.

        Parameter 'metaid' is string representing the metaid of the object to
        find.

        Returns pointer to the first element found with the given 'metaid'.

        """
        return _libsbml.UnitDefinition_getElementByMetaId(self, metaid)


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


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

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is now recommended to use the
        getIdAttribute() function instead.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns the id of this UnitDefinition.

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.UnitDefinition_getId(self)


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


        Returns the value of the 'name' attribute of this UnitDefinition
        object.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns the name of this SBML object, or the empty string if not set
        or unsettable.

        See also getIdAttribute(), isSetName(), setName(), unsetName().

        """
        return _libsbml.UnitDefinition_getName(self)


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


        Predicate returning 'True' if this UnitDefinition's 'id' attribute is
        set.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns 'True' if the 'id' attribute of this SBML object is set,
        'False' otherwise.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is recommended that callers use
        isSetIdAttribute() instead.

        See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(),
        isSetIdAttribute().

        """
        return _libsbml.UnitDefinition_isSetId(self)


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


        Predicate returning 'True' if this UnitDefinition's 'name' attribute
        is set.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns 'True' if the 'name' attribute of this SBML object is set,
        'False' otherwise.

        See also getName(), setName(), unsetName().

        """
        return _libsbml.UnitDefinition_isSetName(self)


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


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

        The string 'sid' is copied.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Parameter 'sid' is the string to use as the identifier of this object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.UnitDefinition_setId(self, sid)


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


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

        The string in 'name' is copied.

        Parameter 'name' is the new name for the SBML object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.UnitDefinition_setName(self, name)


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


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

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getName(), setName(), isSetName().

        """
        return _libsbml.UnitDefinition_unsetName(self)


    def isVariantOfArea(self, relaxed=False):
        """
        isVariantOfArea(UnitDefinition self, bool relaxed=False) -> bool
        isVariantOfArea(UnitDefinition self) -> bool


        Convenience function for testing if a given unit definition is a
        variant of the predefined unit identifier ''area'.'

        Returns 'True' if this UnitDefinition is a variant of the predefined
        unit 'area,' meaning square metres with only arbitrary variations in
        scale or multiplier values; 'False' otherwise.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        return _libsbml.UnitDefinition_isVariantOfArea(self, relaxed)


    def isVariantOfLength(self, relaxed=False):
        """
        isVariantOfLength(UnitDefinition self, bool relaxed=False) -> bool
        isVariantOfLength(UnitDefinition self) -> bool


        Convenience function for testing if a given unit definition is a
        variant of the predefined unit identifier ''length'.'

        Returns 'True' if this UnitDefinition is a variant of the predefined
        unit 'length,' meaning metres with only arbitrary variations in scale
        or multiplier values; 'False' otherwise.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        return _libsbml.UnitDefinition_isVariantOfLength(self, relaxed)


    def isVariantOfSubstance(self, relaxed=False):
        """
        isVariantOfSubstance(UnitDefinition self, bool relaxed=False) -> bool
        isVariantOfSubstance(UnitDefinition self) -> bool


        Convenience function for testing if a given unit definition is a
        variant of the predefined unit identifier ''substance'.'

        Returns 'True' if this UnitDefinition is a variant of the predefined
        unit 'substance,' meaning moles or items (and grams or kilograms from
        SBML Level 2 Version 2 onwards) with only arbitrary variations in
        scale or multiplier values; 'False' otherwise.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        return _libsbml.UnitDefinition_isVariantOfSubstance(self, relaxed)


    def isVariantOfTime(self, relaxed=False):
        """
        isVariantOfTime(UnitDefinition self, bool relaxed=False) -> bool
        isVariantOfTime(UnitDefinition self) -> bool


        Convenience function for testing if a given unit definition is a
        variant of the predefined unit identifier ''time'.'

        Returns 'True' if this UnitDefinition is a variant of the predefined
        unit 'time,' meaning seconds with only arbitrary variations in scale
        or multiplier values; 'False' otherwise.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        return _libsbml.UnitDefinition_isVariantOfTime(self, relaxed)


    def isVariantOfVolume(self, relaxed=False):
        """
        isVariantOfVolume(UnitDefinition self, bool relaxed=False) -> bool
        isVariantOfVolume(UnitDefinition self) -> bool


        Convenience function for testing if a given unit definition is a
        variant of the predefined unit identifier ''volume'.'

        Returns 'True' if this UnitDefinition is a variant of the predefined
        unit 'volume,' meaning litre or cubic metre with only arbitrary
        variations in scale or multiplier values; 'False' otherwise.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        return _libsbml.UnitDefinition_isVariantOfVolume(self, relaxed)


    def isVariantOfDimensionless(self, relaxed=False):
        """
        isVariantOfDimensionless(UnitDefinition self, bool relaxed=False) -> bool
        isVariantOfDimensionless(UnitDefinition self) -> bool


        Convenience function for testing if a given unit definition is a
        variant of the unit ''dimensionless'.'

        Returns 'True' if this UnitDefinition is a variant of 'dimensionless,'
        meaning dimensionless with only arbitrary variations in scale or
        multiplier values; 'False' otherwise.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        return _libsbml.UnitDefinition_isVariantOfDimensionless(self, relaxed)


    def isVariantOfMass(self, relaxed=False):
        """
        isVariantOfMass(UnitDefinition self, bool relaxed=False) -> bool
        isVariantOfMass(UnitDefinition self) -> bool


        Convenience function for testing if a given unit definition is a
        variant of the predefined unit identifier ''mass'.'

        Returns 'True' if this UnitDefinition is a variant of mass units,
        meaning gram or kilogram with only arbitrary variations in scale or
        multiplier values; 'False' otherwise.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        return _libsbml.UnitDefinition_isVariantOfMass(self, relaxed)


    def isVariantOfSubstancePerTime(self, relaxed=False):
        """
        isVariantOfSubstancePerTime(UnitDefinition self, bool relaxed=False) -> bool
        isVariantOfSubstancePerTime(UnitDefinition self) -> bool


        Convenience function for testing if a given unit definition is a
        variant of the predefined unit ''substance'' divided by the predefined
        unit ''time'.'

        Returns 'True' if this UnitDefinition is a variant of the predefined
        unit 'substance' per predefined unit '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; 'False' otherwise.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        return _libsbml.UnitDefinition_isVariantOfSubstancePerTime(self, relaxed)


    def addUnit(self, u):
        """
        addUnit(UnitDefinition self, Unit u) -> int


        Adds a copy of the given Unit to this UnitDefinition.

        Parameter 'u' is the Unit instance to add to this UnitDefinition.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_OPERATION_FAILED

        Note: This method should be used with some caution.  The fact that
        this method copies the object passed to it means that the caller will
        be left holding a physically different object instance than the one
        contained inside this object.  Changes made to the original object
        instance (such as resetting attribute values) will not affect the
        instance in this object.  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 other methods on this class
        (particularly a corresponding method whose name begins with the word
        create) for alternatives that do not lead to these issues.

        See also createUnit().

        """
        return _libsbml.UnitDefinition_addUnit(self, u)


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


        Creates a new and empty Unit, adds it to this UnitDefinition's list of
        units, and returns it.

        Returns 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 UNIT_KIND_INVALID). Callers are
        cautioned to set the newly-constructed Unit's kind using
        Unit.setKind() soon after calling this method.

        See also addUnit().

        """
        return _libsbml.UnitDefinition_createUnit(self)


    def getListOfUnits(self, *args):
        """
        getListOfUnits(UnitDefinition self) -> ListOfUnits
        getListOfUnits(UnitDefinition self) -> ListOfUnits


        Returns the list of Units for this UnitDefinition instance. Returns
        the ListOfUnits value for this UnitDefinition.

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


    def getUnit(self, *args):
        """
        getUnit(UnitDefinition self, unsigned int n) -> Unit
        getUnit(UnitDefinition self, unsigned int n) -> Unit


        Returns a specific Unit instance belonging to this UnitDefinition.

        Parameter 'n' is an integer, the index of the Unit to be returned.

        Returns the nth Unit of this UnitDefinition. If the index 'n' is
        invalid, 'None' is returned.

        See also getNumUnits().

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


    def getNumUnits(self):
        """
        getNumUnits(UnitDefinition self) -> unsigned int


        Returns the number of Unit objects contained within this
        UnitDefinition.

        Returns an integer representing the number of Units in this
        UnitDefinition.

        """
        return _libsbml.UnitDefinition_getNumUnits(self)


    def removeUnit(self, n):
        """
        removeUnit(UnitDefinition 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.

        Parameter 'n' is the index of the Unit object to remove.

        Returns the Unit object removed, or 'None' if the given index  is out
        of range.

        """
        return _libsbml.UnitDefinition_removeUnit(self, n)


    def connectToChild(self):
        """connectToChild(UnitDefinition self)"""
        return _libsbml.UnitDefinition_connectToChild(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(UnitDefinition self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.UnitDefinition_enablePackageInternal(self, pkgURI, pkgPrefix, flag)


    def updateSBMLNamespace(self, package, level, version):
        """
        updateSBMLNamespace(UnitDefinition self, string package, unsigned int level, unsigned int version)


        Internal implementation method.

        """
        return _libsbml.UnitDefinition_updateSBMLNamespace(self, package, level, version)


    def getTypeCode(self):
        """
        getTypeCode(UnitDefinition self) -> int


        Returns the libSBML type code for this object instance.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_UNIT_DEFINITION
        (default).

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getPackageName(), getElementName().

        """
        return _libsbml.UnitDefinition_getTypeCode(self)


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


        Returns the XML element name of this object, which for UnitDefinition,
        is always ''unitDefinition'.'

        Returns the name of this element, i.e., ''unitDefinition'.'

        """
        return _libsbml.UnitDefinition_getElementName(self)


    def simplify(ud):
        """
        simplify(UnitDefinition ud)


        Simplifies the UnitDefinition such that any given kind of Unit object
        occurs only once in the ListOfUnits.

        For example, the following definition,

           <unitDefinition>
            <listOfUnits>
              <unit kind='metre' exponent='1'/>
              <unit kind='metre' exponent='2'/>
            </listOfUnits>
           <unitDefinition>

        will be simplified to

           <unitDefinition>
             <listOfUnits>
               <unit kind='metre' exponent='3'/>
             </listOfUnits>
           <unitDefinition>

        Parameter 'ud' is the UnitDefinition object to be simplified.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.UnitDefinition_simplify(ud)

    simplify = staticmethod(simplify)

    def reorder(ud):
        """
        reorder(UnitDefinition ud)


        Alphabetically orders the Unit objects within the ListOfUnits of a
        UnitDefinition.

        Parameter 'ud' is the UnitDefinition object whose units are to be
        reordered.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.UnitDefinition_reorder(ud)

    reorder = staticmethod(reorder)

    def convertToSI(ud):
        """
        convertToSI(UnitDefinition ud) -> UnitDefinition


        Convert a given UnitDefinition into a new UnitDefinition object that
        uses SI units.

        Parameter 'ud' is the UnitDefinition object to convert to SI.

        Returns a new UnitDefinition object representing the results of the
        conversion.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.UnitDefinition_convertToSI(ud)

    convertToSI = staticmethod(convertToSI)

    def areIdentical(ud1, ud2):
        """
        areIdentical(UnitDefinition ud1, UnitDefinition ud2) -> bool


        Predicate returning 'True' if 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.

        Parameter 'ud1' is the first UnitDefinition object to compare.
        Parameter 'ud2' is the second UnitDefinition object to compare.

        Returns 'True' if all the Unit objects in 'ud1' are identical to the
        Unit objects of 'ud2', 'False' otherwise.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        See also UnitDefinition.areEquivalent(), Unit.areIdentical().

        """
        return _libsbml.UnitDefinition_areIdentical(ud1, ud2)

    areIdentical = staticmethod(areIdentical)

    def areEquivalent(ud1, ud2):
        """
        areEquivalent(UnitDefinition ud1, UnitDefinition ud2) -> bool


        Predicate returning 'True' if two UnitDefinition objects are
        equivalent.

        For the purposes of performing this comparison, two UnitDefinition
        objects are considered equivalent when they contain 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.

        Parameter 'ud1' is the first UnitDefinition object to compare.

        Parameter 'ud2' is the second UnitDefinition object to compare.

        Returns 'True' if all the Unit objects in 'ud1' are equivalent to the
        Unit objects in 'ud2', 'False' otherwise.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        See also UnitDefinition.areIdentical(), Unit.areEquivalent().

        """
        return _libsbml.UnitDefinition_areEquivalent(ud1, ud2)

    areEquivalent = staticmethod(areEquivalent)

    def combine(ud1, ud2):
        """
        combine(UnitDefinition ud1, UnitDefinition ud2) -> UnitDefinition


        Combines two UnitDefinition objects into a single UnitDefinition.

        This takes UnitDefinition objects 'ud1' and 'ud2', and creates a
        UnitDefinition object that expresses the product of the units of 'ud1'
        and 'ud2'.

        Parameter 'ud1' is the first UnitDefinition object. Parameter 'ud2' is
        the second UnitDefinition object.

        Returns a UnitDefinition which represents the product of the  units of
        the two argument UnitDefinitions.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.UnitDefinition_combine(ud1, ud2)

    combine = staticmethod(combine)

    def divide(ud1, ud2):
        """
        divide(UnitDefinition ud1, UnitDefinition ud2) -> UnitDefinition


        Combines two UnitDefinition objects into a single UnitDefinition as a
        division.

        This takes UnitDefinition objects 'ud1' and 'ud2', and creates a
        UnitDefinition object that expresses the division of the units of
        'ud1' and 'ud2'.

        Parameter 'ud1' is the first UnitDefinition object. Parameter 'ud2' is
        the second UnitDefinition object.

        Returns a UnitDefinition which represents the division of the  units
        of the two argument UnitDefinitions.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.UnitDefinition_divide(ud1, ud2)

    divide = staticmethod(divide)

    def printUnits(ud, compact=False):
        """
        printUnits(UnitDefinition ud, bool compact=False) -> string
        printUnits(UnitDefinition ud) -> string


        Expresses the given definition in a plain-text form.

        For example, UnitDefinition.printUnits() applied to

           <unitDefinition>
            <listOfUnits>
              <unit kind='metre' exponent='1'/>
              <unit kind='second' exponent='-2'/>
            </listOfUnits>
           <unitDefinition>

        will return the string 'metre (exponent = 1, multiplier = 1, scale =
        0) second (exponent = -2, multiplier = 1, scale = 0)' or, if the
        optional parameter 'compact' is given the value 'True,' the string '(1
        metre)^1 (1 second)^-2'.  This method may be useful for printing unit
        information to human users, or in debugging software, or other
        situations.

        Parameter 'ud' is the UnitDefinition object. Parameter 'compact' is
        boolean indicating whether the compact form should be used (defaults
        to false).

        Returns a string expressing the unit definition defined by the given
        UnitDefinition object 'ud'.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        return _libsbml.UnitDefinition_printUnits(ud, compact)

    printUnits = staticmethod(printUnits)

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


        Predicate returning 'True' if all the required attributes for this
        UnitDefinition object have been set.

        The required attributes for a UnitDefinition object are:

        * 'id'

        Returns 'True' if the required attributes have been set, 'False'
        otherwise.

        """
        return _libsbml.UnitDefinition_hasRequiredAttributes(self)


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


        Predicate returning 'True' if all the required elements for this
        UnitDefinition object have been set.

        Note: The required elements for a Constraint object are:

        * 'listOfUnits' (required in SBML Level 2 only, optional in Level
        3)

        Returns 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(ud):
    """
    UnitDefinition_simplify(UnitDefinition ud)


    Simplifies the UnitDefinition such that any given kind of Unit object
    occurs only once in the ListOfUnits.

    For example, the following definition,

       <unitDefinition>
        <listOfUnits>
          <unit kind='metre' exponent='1'/>
          <unit kind='metre' exponent='2'/>
        </listOfUnits>
       <unitDefinition>

    will be simplified to

       <unitDefinition>
         <listOfUnits>
           <unit kind='metre' exponent='3'/>
         </listOfUnits>
       <unitDefinition>

    Parameter 'ud' is the UnitDefinition object to be simplified.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.UnitDefinition_simplify(ud)

def UnitDefinition_reorder(ud):
    """
    UnitDefinition_reorder(UnitDefinition ud)


    Alphabetically orders the Unit objects within the ListOfUnits of a
    UnitDefinition.

    Parameter 'ud' is the UnitDefinition object whose units are to be
    reordered.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.UnitDefinition_reorder(ud)

def UnitDefinition_convertToSI(ud):
    """
    UnitDefinition_convertToSI(UnitDefinition ud) -> UnitDefinition


    Convert a given UnitDefinition into a new UnitDefinition object that
    uses SI units.

    Parameter 'ud' is the UnitDefinition object to convert to SI.

    Returns a new UnitDefinition object representing the results of the
    conversion.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.UnitDefinition_convertToSI(ud)

def UnitDefinition_areIdentical(ud1, ud2):
    """
    UnitDefinition_areIdentical(UnitDefinition ud1, UnitDefinition ud2) -> bool


    Predicate returning 'True' if 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.

    Parameter 'ud1' is the first UnitDefinition object to compare.
    Parameter 'ud2' is the second UnitDefinition object to compare.

    Returns 'True' if all the Unit objects in 'ud1' are identical to the
    Unit objects of 'ud2', 'False' otherwise.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    See also UnitDefinition.areEquivalent(), Unit.areIdentical().

    """
    return _libsbml.UnitDefinition_areIdentical(ud1, ud2)

def UnitDefinition_areEquivalent(ud1, ud2):
    """
    UnitDefinition_areEquivalent(UnitDefinition ud1, UnitDefinition ud2) -> bool


    Predicate returning 'True' if two UnitDefinition objects are
    equivalent.

    For the purposes of performing this comparison, two UnitDefinition
    objects are considered equivalent when they contain 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.

    Parameter 'ud1' is the first UnitDefinition object to compare.

    Parameter 'ud2' is the second UnitDefinition object to compare.

    Returns 'True' if all the Unit objects in 'ud1' are equivalent to the
    Unit objects in 'ud2', 'False' otherwise.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    See also UnitDefinition.areIdentical(), Unit.areEquivalent().

    """
    return _libsbml.UnitDefinition_areEquivalent(ud1, ud2)

def UnitDefinition_combine(ud1, ud2):
    """
    UnitDefinition_combine(UnitDefinition ud1, UnitDefinition ud2) -> UnitDefinition


    Combines two UnitDefinition objects into a single UnitDefinition.

    This takes UnitDefinition objects 'ud1' and 'ud2', and creates a
    UnitDefinition object that expresses the product of the units of 'ud1'
    and 'ud2'.

    Parameter 'ud1' is the first UnitDefinition object. Parameter 'ud2' is
    the second UnitDefinition object.

    Returns a UnitDefinition which represents the product of the  units of
    the two argument UnitDefinitions.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.UnitDefinition_combine(ud1, ud2)

def UnitDefinition_divide(ud1, ud2):
    """
    UnitDefinition_divide(UnitDefinition ud1, UnitDefinition ud2) -> UnitDefinition


    Combines two UnitDefinition objects into a single UnitDefinition as a
    division.

    This takes UnitDefinition objects 'ud1' and 'ud2', and creates a
    UnitDefinition object that expresses the division of the units of
    'ud1' and 'ud2'.

    Parameter 'ud1' is the first UnitDefinition object. Parameter 'ud2' is
    the second UnitDefinition object.

    Returns a UnitDefinition which represents the division of the  units
    of the two argument UnitDefinitions.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.UnitDefinition_divide(ud1, ud2)

def UnitDefinition_printUnits(ud, compact=False):
    """
    printUnits(UnitDefinition ud, bool compact=False) -> string
    UnitDefinition_printUnits(UnitDefinition ud) -> string


    Expresses the given definition in a plain-text form.

    For example, UnitDefinition.printUnits() applied to

       <unitDefinition>
        <listOfUnits>
          <unit kind='metre' exponent='1'/>
          <unit kind='second' exponent='-2'/>
        </listOfUnits>
       <unitDefinition>

    will return the string 'metre (exponent = 1, multiplier = 1, scale =
    0) second (exponent = -2, multiplier = 1, scale = 0)' or, if the
    optional parameter 'compact' is given the value 'True,' the string '(1
    metre)^1 (1 second)^-2'.  This method may be useful for printing unit
    information to human users, or in debugging software, or other
    situations.

    Parameter 'ud' is the UnitDefinition object. Parameter 'compact' is
    boolean indicating whether the compact form should be used (defaults
    to false).

    Returns a string expressing the unit definition defined by the given
    UnitDefinition object 'ud'.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    Note: Owing to the way that language interfaces are created in
    libSBML, this documentation may show methods that define default
    values for parameters with text that has the form parameter = value.
    This is not to be intepreted as a Python keyword argument; the use of
    a parameter name followed by an equals sign followed by a value is
    only meant to indicate a default value if the argument is not provided
    at all.  It is not a keyword in the Python sense.

    """
    return _libsbml.UnitDefinition_printUnits(ud, compact)

class ListOfUnitDefinitions(ListOf):
    """

    A list of UnitDefinition objects.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, 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 __init__(self, *args):
        """
        __init__(ListOfUnitDefinitions self, unsigned int level, unsigned int version) -> ListOfUnitDefinitions
        __init__(ListOfUnitDefinitions self, SBMLNamespaces sbmlns) -> ListOfUnitDefinitions


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfUnitDefinitions(SBMLNamespaces sbmlns)

        Creates a new ListOfUnitDefinitions object.

        The object is constructed such that it is valid for the SBML Level and
        Version combination determined by the SBMLNamespaces object in
        'sbmlns'.

        Parameter 'sbmlns' is an SBMLNamespaces object that is used to
        determine the characteristics of the ListOfUnitDefinitions object to
        be created.

        Throws SBMLConstructorException: Thrown if the given 'sbmlns' is
        inconsistent or incompatible with this object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfUnitDefinitions(long level, long version)

        Creates a new ListOfUnitDefinitions object.

        The object is constructed such that it is valid for the given SBML
        Level and Version combination.

        Parameter 'level' is the SBML Level.

        Parameter 'version' is the Version within the SBML Level.

        Throws SBMLConstructorException: Thrown if the given 'level' and
        'version' combination are invalid or if this object is incompatible
        with the given level and version.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        """
        this = _libsbml.new_ListOfUnitDefinitions(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ListOfUnitDefinitions self) -> ListOfUnitDefinitions


        Creates and returns a deep copy of this ListOfUnitDefinitions object.

        Returns the (deep) copy of this ListOfUnitDefinitions object.

        """
        return _libsbml.ListOfUnitDefinitions_clone(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfUnitDefinitions self) -> int


        Returns the libSBML type code for the objects contained in this ListOf
        (i.e., UnitDefinition objects, if the list is non-empty).

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for objects contained in this list:
        SBML_UNIT_DEFINITION (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfUnitDefinitions_getItemTypeCode(self)


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


        Returns the XML element name of this object.

        For ListOfUnitDefinitions, the XML element name is
        ''listOfUnitDefinitions'.'

        Returns the name of this element, i.e., ''listOfUnitDefinitions'.'

        """
        return _libsbml.ListOfUnitDefinitions_getElementName(self)


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a UnitDefinition from the ListOfUnitDefinitions.

        Parameter 'n' is the index number of the UnitDefinition to get.

        Returns the nth UnitDefinition in this ListOfUnitDefinitions. If the
        index 'n' is invalid, 'None' is returned.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a UnitDefinition from the ListOfUnitDefinitions based on its
        identifier.

        Parameter 'sid' is a string representing the identifier  of the
        UnitDefinition to get.

        Returns UnitDefinition in this ListOfUnitDefinitions with the given
        'sid' or 'None' if no such UnitDefinition exists.

        See also get(), size().

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


    def getElementBySId(self, id):
        """
        getElementBySId(ListOfUnitDefinitions self, string id) -> SBase


        Returns the first child element found that has the given 'id' in the
        model-wide SId namespace, or 'None' if no such object is found.

        Note that UnitDefinitions themselves are in the UnitId namespace, not
        the SId namespace, so no UnitDefinition object will be returned from
        this function (and is the reason we override the base
        ListOf::getElementBySId function here).

        Parameter 'id' is string representing the id of the object to find.

        Returns pointer to the first element found with the given 'id'.

        """
        return _libsbml.ListOfUnitDefinitions_getElementBySId(self, id)


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth item from this ListOfUnitDefinitions items and returns
        a pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the item to remove.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        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 'sid', then
        'None' is returned.

        Parameter 'sid' is the identifier of the item to remove.

        Returns the item removed.  As mentioned above, the caller owns the
        returned item.

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

    __swig_destroy__ = _libsbml.delete_ListOfUnitDefinitions
    __del__ = lambda self: None
ListOfUnitDefinitions_swigregister = _libsbml.ListOfUnitDefinitions_swigregister
ListOfUnitDefinitions_swigregister(ListOfUnitDefinitions)

class CompartmentType(SBase):
    """

    A compartment type in SBML Level 2.

    SBML Level 2 Versions 2-4 provide the compartment type as a grouping
    construct that can be used to establish a relationship between
    multiple Compartment objects.  A CompartmentType object only has an
    identity, and this identity can only be used to indicate that
    particular Compartment objects in the model 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 within SBML itself to indicate that
    all of the compartments share an underlying conceptual relationship
    because each SBML compartment must be given a unique and separate
    identity.  A CompartmentType has no mathematical meaning in SBML---it
    has 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 Level 2 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 '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 SBML Level 1 nor in Level 3.

    See also Compartment, ListOfCompartmentTypes, SpeciesType,
    ListOfSpeciesTypes.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CompartmentType, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CompartmentType, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_CompartmentType
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(CompartmentType self, unsigned int level, unsigned int version) -> CompartmentType
        __init__(CompartmentType self, SBMLNamespaces sbmlns) -> CompartmentType
        __init__(CompartmentType self, CompartmentType orig) -> CompartmentType


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            CompartmentType(SBMLNamespaces sbmlns)

        Creates a new CompartmentType object using the given SBMLNamespaces
        object 'sbmlns'.

        The SBMLNamespaces object encapsulates SBML Level/Version/namespaces
        information.  It is used to communicate the SBML Level, Version, and
        (in Level 3) packages used in addition to SBML Level 3 Core.  A common
        approach to using libSBML's SBMLNamespaces facilities is to create an
        SBMLNamespaces object somewhere in a program once, then hand that
        object as needed to object constructors that accept SBMLNamespaces as
        arguments.

        It is worth emphasizing that although this constructor does not take
        an identifier argument, in SBML Level 2 and beyond, the 'id'
        (identifier) attribute of a CompartmentType object is required to have
        a value.  Thus, callers are cautioned to assign a value after calling
        this constructor.  Setting the identifier can be accomplished using
        the method setId().

        Parameter 'sbmlns' is an SBMLNamespaces object.

        Throws SBMLConstructorException: Thrown if the given 'sbmlns' is
        inconsistent or incompatible with this object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            CompartmentType(long level, long version)

        Creates a new CompartmentType object using the given SBML 'level' and
        'version' values.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        CompartmentType.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this CompartmentType.

        Throws SBMLConstructorException: Thrown if the given 'level' and
        'version' combination are invalid or if this object is incompatible
        with the given level and version.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            CompartmentType(CompartmentType orig)

        Copy constructor; creates a copy of this CompartmentType object.

        Parameter 'orig' is the object to copy.

        """
        this = _libsbml.new_CompartmentType(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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


        Creates and returns a deep copy of this CompartmentType object.

        Returns the (deep) copy of this CompartmentType object.

        """
        return _libsbml.CompartmentType_clone(self)


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


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

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is now recommended to use the
        getIdAttribute() function instead.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns the id of this CompartmentType.

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.CompartmentType_getId(self)


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


        Returns the value of the 'name' attribute of this CompartmentType
        object.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns the name of this SBML object, or the empty string if not set
        or unsettable.

        See also getIdAttribute(), isSetName(), setName(), unsetName().

        """
        return _libsbml.CompartmentType_getName(self)


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


        Predicate returning 'True' if this CompartmentType object's 'id'
        attribute is set.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns 'True' if the 'id' attribute of this SBML object is set,
        'False' otherwise.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is recommended that callers use
        isSetIdAttribute() instead.

        See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(),
        isSetIdAttribute().

        """
        return _libsbml.CompartmentType_isSetId(self)


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


        Predicate returning 'True' if this CompartmentType object's 'name'
        attribute is set.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns 'True' if the 'name' attribute of this SBML object is set,
        'False' otherwise.

        See also getName(), setName(), unsetName().

        """
        return _libsbml.CompartmentType_isSetName(self)


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


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

        The string 'sid' is copied.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Parameter 'sid' is the string to use as the identifier of this object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.CompartmentType_setId(self, sid)


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


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

        The string in 'name' is copied.

        Parameter 'name' is the new name for the SBML object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.CompartmentType_setName(self, name)


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


        Unsets the value of the 'name' attribute of this CompartmentType
        object.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getName(), setName(), isSetName().

        """
        return _libsbml.CompartmentType_unsetName(self)


    def getTypeCode(self):
        """
        getTypeCode(CompartmentType self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_COMPARTMENT_TYPE
        (default).

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.CompartmentType_getTypeCode(self)


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


        Returns the XML element name of this object

        For CompartmentType, the element name is always ''compartmentType'.'

        Returns the name of this element.

        See also getTypeCode(), getPackageName().

        """
        return _libsbml.CompartmentType_getElementName(self)


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


        Predicate returning 'True' if all the required attributes for this
        CompartmentType object have been set.

        The required attributes for a CompartmentType object are:

        * 'id'

        Returns 'True' if the required attributes have been set, 'False'
        otherwise.

        """
        return _libsbml.CompartmentType_hasRequiredAttributes(self)

CompartmentType_swigregister = _libsbml.CompartmentType_swigregister
CompartmentType_swigregister(CompartmentType)

class ListOfCompartmentTypes(ListOf):
    """

    A list of CompartmentType objects.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfCompartmentTypes, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfCompartmentTypes, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ListOfCompartmentTypes self, unsigned int level, unsigned int version) -> ListOfCompartmentTypes
        __init__(ListOfCompartmentTypes self, SBMLNamespaces sbmlns) -> ListOfCompartmentTypes


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfCompartmentTypes(SBMLNamespaces sbmlns)

        Creates a new ListOfCompartmentTypes object.

        The object is constructed such that it is valid for the SBML Level and
        Version combination determined by the SBMLNamespaces object in
        'sbmlns'.

        Parameter 'sbmlns' is an SBMLNamespaces object that is used to
        determine the characteristics of the ListOfCompartmentTypes object to
        be created.

        Throws SBMLConstructorException: Thrown if the given 'sbmlns' is
        inconsistent or incompatible with this object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfCompartmentTypes(long level, long version)

        Creates a new ListOfCompartmentTypes object.

        The object is constructed such that it is valid for the given SBML
        Level and Version combination.

        Parameter 'level' is the SBML Level.

        Parameter 'version' is the Version within the SBML Level.

        Throws SBMLConstructorException: Thrown if the given 'level' and
        'version' combination are invalid or if this object is incompatible
        with the given level and version.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        """
        this = _libsbml.new_ListOfCompartmentTypes(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ListOfCompartmentTypes self) -> ListOfCompartmentTypes


        Creates and returns a deep copy of this ListOfCompartmentTypes object.

        Returns the (deep) copy of this ListOfCompartmentTypes object.

        """
        return _libsbml.ListOfCompartmentTypes_clone(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfCompartmentTypes self) -> int


        Returns the libSBML type code for the objects contained in this ListOf
        (i.e., CompartmentType objects, if the list is non-empty).

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for the objects contained in this ListOf
        instance: SBML_COMPARTMENT_TYPE (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfCompartmentTypes_getItemTypeCode(self)


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


        Returns the XML element name of this object.

        For ListOfCompartmentTypes, the XML element name is
        ''listOfCompartmentTypes'.'

        Returns the name of this element, i.e., ''listOfCompartmentTypes'.'

        """
        return _libsbml.ListOfCompartmentTypes_getElementName(self)


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a CompartmentType object from the ListOfCompartmentTypes.

        Parameter 'n' is the index number of the CompartmentType object to
        get.

        Returns the nth CompartmentType object in this ListOfCompartmentTypes.
        If the index 'n' is invalid, 'None' is returned.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a CompartmentType object from the ListOfCompartmentTypes based on
        its identifier.

        Parameter 'sid' is a string representing the identifier of the
        CompartmentType object to get.

        Returns CompartmentType object in this ListOfCompartmentTypes with the
        given 'sid' or 'None' if no such CompartmentType object exists.

        See also get(), size().

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


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth item from this ListOfCompartmentTypes items and
        returns a pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the item to remove.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes item in this ListOfCompartmentTypes 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 'sid', then
        'None' is returned.

        Parameter 'sid' is the identifier of the item to remove.

        Returns the item removed.  As mentioned above, the caller owns the
        returned item.

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

    __swig_destroy__ = _libsbml.delete_ListOfCompartmentTypes
    __del__ = lambda self: None
ListOfCompartmentTypes_swigregister = _libsbml.ListOfCompartmentTypes_swigregister
ListOfCompartmentTypes_swigregister(ListOfCompartmentTypes)

class SpeciesType(SBase):
    """

    A species type in SBML Level 2.

    The term species type refers to reacting entities independent of
    location.  These include simple ions (e.g., protons, calcium), simple
    molecules (e.g., glucose, ATP), large molecules (e.g., RNA,
    polysaccharides, and proteins), and others.

    SBML Level 2 Versions 2-4 provide an explicit SpeciesType class of
    object to enable Species objects of the same type to be related
    together.  SpeciesType is a conceptual construct; the existence of
    SpeciesType objects in a model has no effect on the model's numerical
    interpretation.  Except for the requirement for uniqueness of
    species/species type combinations located in compartments, simulators
    and other numerical analysis software may ignore SpeciesType
    definitions and references to them in a model.

    There is no mechanism in SBML Level 2 for representing hierarchies of
    species types.  One SpeciesType object cannot be the subtype of
    another SpeciesType object; SBML provides no means of defining such
    relationships.

    As with other major structures in SBML, SpeciesType has a mandatory
    attribute, 'id', used to give the species type an identifier.  The
    identifier must be a text string conforming to the identifer syntax
    permitted in SBML.  SpeciesType also has an optional 'name' attribute,
    of type '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).

    SpeciesType was introduced in SBML Level 2 Version 2.  It is not
    available in SBML Level 1 nor in Level 3.

    See also Species, ListOfSpeciesTypes, CompartmentType,
    ListOfCompartmentTypes.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SpeciesType, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SpeciesType, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_SpeciesType
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(SpeciesType self, unsigned int level, unsigned int version) -> SpeciesType
        __init__(SpeciesType self, SBMLNamespaces sbmlns) -> SpeciesType
        __init__(SpeciesType self, SpeciesType orig) -> SpeciesType


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            SpeciesType(SBMLNamespaces sbmlns)

        Creates a new SpeciesType using the given SBMLNamespaces object
        'sbmlns'.

        The SBMLNamespaces object encapsulates SBML Level/Version/namespaces
        information.  It is used to communicate the SBML Level, Version, and
        (in Level 3) packages used in addition to SBML Level 3 Core.  A common
        approach to using libSBML's SBMLNamespaces facilities is to create an
        SBMLNamespaces object somewhere in a program once, then hand that
        object as needed to object constructors that accept SBMLNamespaces as
        arguments.

        It is worth emphasizing that although this constructor does not take
        an identifier argument, in SBML Level 2 and beyond, the 'id'
        (identifier) attribute of a SpeciesType object is required to have a
        value. Thus, callers are cautioned to assign a value after calling
        this constructor.  Setting the identifier can be accomplished using
        the method SBase.setId().

        Parameter 'sbmlns' is an SBMLNamespaces object.

        Throws SBMLConstructorException: Thrown if the given 'sbmlns' is
        inconsistent or incompatible with this object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            SpeciesType(long level, long version)

        Creates a new SpeciesType using the given SBML 'level' and 'version'
        values.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        SpeciesType.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this SpeciesType.

        Throws SBMLConstructorException: Thrown if the given 'level' and
        'version' combination are invalid or if this object is incompatible
        with the given level and version.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            SpeciesType(SpeciesType orig)

        Copy constructor; creates a copy of this SpeciesType.

        Parameter 'orig' is the object to copy.

        """
        this = _libsbml.new_SpeciesType(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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


        Creates and returns a deep copy of this SpeciesType object.

        Returns the (deep) copy of this SpeciesType object.

        """
        return _libsbml.SpeciesType_clone(self)


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


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

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is now recommended to use the
        getIdAttribute() function instead.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns the id of this SpeciesType.

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.SpeciesType_getId(self)


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


        Returns the value of the 'name' attribute of this SpeciesType object.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns the name of this SBML object, or the empty string if not set
        or unsettable.

        See also getIdAttribute(), isSetName(), setName(), unsetName().

        """
        return _libsbml.SpeciesType_getName(self)


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


        Predicate returning 'True' if this SpeciesType's 'id' attribute is
        set.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns 'True' if the 'id' attribute of this SBML object is set,
        'False' otherwise.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is recommended that callers use
        isSetIdAttribute() instead.

        See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(),
        isSetIdAttribute().

        """
        return _libsbml.SpeciesType_isSetId(self)


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


        Predicate returning 'True' if this SpeciesType's 'name' attribute is
        set.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns 'True' if the 'name' attribute of this SBML object is set,
        'False' otherwise.

        See also getName(), setName(), unsetName().

        """
        return _libsbml.SpeciesType_isSetName(self)


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


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

        The string 'sid' is copied.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Parameter 'sid' is the string to use as the identifier of this object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.SpeciesType_setId(self, sid)


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


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

        The string in 'name' is copied.

        Parameter 'name' is the new name for the SBML object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.SpeciesType_setName(self, name)


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


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

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getName(), setName(), isSetName().

        """
        return _libsbml.SpeciesType_unsetName(self)


    def getTypeCode(self):
        """
        getTypeCode(SpeciesType self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_SPECIES_TYPE
        (default).

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.SpeciesType_getTypeCode(self)


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


        Returns the XML element name of this object, which for SpeciesType, is
        always ''compartmentType'.'

        Returns the name of this element, i.e., ''compartmentType'.'

        """
        return _libsbml.SpeciesType_getElementName(self)


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


        Predicate returning 'True' if all the required attributes for this
        SpeciesType object have been set.

        The required attributes for a SpeciesType object are:

        * 'id'

        Returns 'True' if the required attributes have been set, 'False'
        otherwise.

        """
        return _libsbml.SpeciesType_hasRequiredAttributes(self)

SpeciesType_swigregister = _libsbml.SpeciesType_swigregister
SpeciesType_swigregister(SpeciesType)

class ListOfSpeciesTypes(ListOf):
    """

    A list of SpeciesType objects.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfSpeciesTypes, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfSpeciesTypes, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ListOfSpeciesTypes self, unsigned int level, unsigned int version) -> ListOfSpeciesTypes
        __init__(ListOfSpeciesTypes self, SBMLNamespaces sbmlns) -> ListOfSpeciesTypes


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfSpeciesTypes(SBMLNamespaces sbmlns)

        Creates a new ListOfSpeciesTypes object.

        The object is constructed such that it is valid for the SBML Level and
        Version combination determined by the SBMLNamespaces object in
        'sbmlns'.

        Parameter 'sbmlns' is an SBMLNamespaces object that is used to
        determine the characteristics of the ListOfSpeciesTypes object to be
        created.

        Throws SBMLConstructorException: Thrown if the given 'sbmlns' is
        inconsistent or incompatible with this object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfSpeciesTypes(long level, long version)

        Creates a new ListOfSpeciesTypes object.

        The object is constructed such that it is valid for the given SBML
        Level and Version combination.

        Parameter 'level' is the SBML Level.

        Parameter 'version' is the Version within the SBML Level.

        Throws SBMLConstructorException: Thrown if the given 'level' and
        'version' combination are invalid or if this object is incompatible
        with the given level and version.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        """
        this = _libsbml.new_ListOfSpeciesTypes(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ListOfSpeciesTypes self) -> ListOfSpeciesTypes


        Creates and returns a deep copy of this ListOfSpeciesTypes object.

        Returns the (deep) copy of this ListOfSpeciesTypes object.

        """
        return _libsbml.ListOfSpeciesTypes_clone(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfSpeciesTypes self) -> int


        Returns the libSBML type code for the objects contained in this ListOf
        (i.e., SpeciesType objects, if the list is non-empty).

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for objects contained in this list:
        SBML_SPECIES_TYPE (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfSpeciesTypes_getItemTypeCode(self)


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


        Returns the XML element name of this object.

        For ListOfSpeciesTypes, the XML element name is
        ''listOfSpeciesTypes'.'

        Returns the name of this element, i.e., ''listOfSpeciesTypes'.'

        """
        return _libsbml.ListOfSpeciesTypes_getElementName(self)


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a SpeciesType from the ListOfSpeciesTypes.

        Parameter 'n' is the index number of the SpeciesType to get.

        Returns the nth SpeciesType in this ListOfSpeciesTypes. If the index
        'n' is invalid, 'None' is returned.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a SpeciesType from the ListOfSpeciesTypes based on its identifier.

        Parameter 'sid' is a string representing the identifier  of the
        SpeciesType to get.

        Returns SpeciesType in this ListOfSpeciesTypes with the given 'sid' or
        'None' if no such SpeciesType exists.

        See also get(), size().

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


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth item from this ListOfSpeciesTypes items and returns a
        pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the item to remove.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes item in this ListOfSpeciesTypes 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 'sid', then
        'None' is returned.

        Parameter 'sid' is the identifier of the item to remove.

        Returns the item removed.  As mentioned above, the caller owns the
        returned item.

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

    __swig_destroy__ = _libsbml.delete_ListOfSpeciesTypes
    __del__ = lambda self: None
ListOfSpeciesTypes_swigregister = _libsbml.ListOfSpeciesTypes_swigregister
ListOfSpeciesTypes_swigregister(ListOfSpeciesTypes)

class Compartment(SBase):
    """

    An SBML compartment, where species are located.

    A compartment in SBML represents a bounded space in which species are
    located.  Compartments do not necessarily have to correspond to actual
    structures inside or outside of a biological cell.

    It is important to note that although compartments are optional in the
    overall definition of Model, every species in an SBML model must be
    located in a compartment.  This in turn means that if a model defines
    any species, the model must also define at least one compartment.  The
    reason is simply that species represent physical things, and therefore
    must exist somewhere.  Compartments represent the somewhere.

    Compartment has one required attribute, 'id', to give the compartment
    a unique identifier by which other parts of an SBML model definition
    can refer to it.  A compartment can also have an optional 'name'
    attribute of type 'string.'  Identifiers and names must be used
    according to the guidelines described in the SBML specifications.

    Compartment also has an optional attribute 'spatialDimensions' that is
    used to indicate the number of spatial dimensions possessed by the
    compartment.  Most modeling scenarios involve compartments with
    integer values of 'spatialDimensions' of '3' (i.e., a three-
    dimensional compartment, which is to say, a volume), or 2 (a two-
    dimensional compartment, a surface), or '1' (a one-dimensional
    compartment, a line).  In SBML Level 3, the type of this attribute is
    'float,' there are no restrictions on the permitted values of the
    'spatialDimensions' attribute, and there are no default values.  In
    SBML Level 2, the value must be a positive 'integer,' and the default
    value is '3;' the permissible values in SBML Level 2 are '3,' '2,'
    '1,' and '0' (for a point).

    Another optional attribute on Compartment is 'size', representing the
    initial total size of that compartment in the model.  The 'size'
    attribute must be a floating-point value and may represent a volume
    (if the compartment is a three-dimensional one), or an area (if the
    compartment is two-dimensional), or a length (if the compartment is
    one-dimensional). There is no default value of compartment size in
    SBML Level 2 or Level 3.  In particular, a missing 'size' value does
    not imply that the compartment size is 1.  (This is unlike the
    definition of compartment 'volume' in SBML Level 1.)  When the
    compartment's 'spatialDimensions' attribute does not have a value of
    '0,' a missing value of 'size' for a given compartment signifies that
    the value either is unknown, or to be obtained from an external
    source, or determined by an InitialAssignment, AssignmentRule,
    AlgebraicRule or RateRule object elsewhere in the model.  In SBML
    Level 2, there are additional special requirements on the values of
    'size'; we discuss them in a separate section below.

    The units associated with a compartment's 'size' attribute value may
    be set using the optional attribute 'units'.  The rules for setting
    and using compartment size units differ between SBML Level 2 and Level
    3, and are discussed separately below.

    Finally, the Compartment attribute named 'constant' is used to
    indicate whether the compartment's size stays constant after
    simulation begins.  A value of 'True' indicates the compartment's
    'size' cannot be changed by any other construct except
    InitialAssignment; a value of 'False' indicates the compartment's
    'size' can be changed by other constructs in SBML.  In SBML Level 2,
    there is an additional explicit restriction that if
    'spatialDimensions'=''0',' the value cannot be changed by
    InitialAssignment either.  Further, in Level 2, 'constant' is
    optional, and has a default value of 'True.'  In SBML Level 3, there
    is no default value for the 'constant' attribute, and it is required.

    Additional considerations in SBML Level 2
    ======================================================================

    In SBML Level 2, the default units of compartment size, and the kinds
    of units allowed as values of the attribute 'units', interact with the
    number of spatial dimensions of the compartment.  The value of the
    'units' attribute of a Compartment object must be one of the base
    units (see Unit), or the predefined unit identifiers 'volume,' 'area,'
    'length' or 'dimensionless,' or a new unit defined by a UnitDefinition
    object in the enclosing Model, subject to the restrictions detailed in
    the following table:

      +----------------------------+---------------+----------------+-----------------------------------+----------------------------------+
      | Value of spatialDimensions | size allowed? | units allowed? | Allowable kinds of units          | Default value of attribute units |
      +----------------------------+---------------+----------------+-----------------------------------+----------------------------------+
      | 3                          | yes           | yes            | units of volume, or dimensionless | volume                           |
      | 2                          | yes           | yes            | units of area, or dimensionless   | area                             |
      | 1                          | yes           | yes            | units of length, or dimensionless | length                           |
      | 0                          | no            | no             | (no units allowed)                |                                  |
      +----------------------------+---------------+----------------+-----------------------------------+----------------------------------+

    In SBML Level 2, the units of the compartment size, as defined by
    the 'units' attribute or (if 'units' is not set) the default value
    listed in the table above, are used in the following ways when the
    compartment has a 'spatialDimensions' value greater than '0:'

    * The value of the 'units' attribute is used as the units of the
    compartment identifier when the identifier appears as a numerical
    quantity in a mathematical formula expressed in MathML.

    * The 'math' element of an AssignmentRule or InitialAssignment
    referring to this compartment must (in Level 2 Versions 1-3) or should
    (in Level 2 Version 4) have identical units.

    * In RateRule objects that set the rate of change of the compartment's
    size, the units of the rule's 'math' element must (in Level 2
    Versions 1-3) or should (in Level 2 Version 4) be identical to the
    compartment's units (whether defined by the 'units' attribute or by
    taking the  default value from the Model) divided by the default time
    units. (In other words, the units for the rate of change of
    compartment size are compartment size/time units.

    * When a Species is to be treated in terms of concentrations or
    density, the units of the spatial size portion of the concentration
    value (i.e., the denominator in the units formula substance/size) are
    those indicated by the value of the 'units' attribute on the
    compartment in which the species is located. Compartments with
    'spatialDimensions'='0' require special treatment in this framework.
    As implied above, the 'size' attribute must not have a value on an
    SBML Level 2 Compartment object if the 'spatialDimensions' attribute
    has a value of '0.'  An additional related restriction is that the
    'constant' attribute must default to or be set to 'True' if the value
    of the 'spatialDimensions' attribute is '0,' because a zero-
    dimensional compartment cannot ever have a size.

    If a compartment has no size or dimensional units, how should such a
    compartment's identifier be interpreted when it appears in
    mathematical formulas?  The answer is that such a compartment's
    identifier should not appear in mathematical formulas in the first
    place---it has no value, and its value cannot change.  Note also that
    a zero-dimensional compartment is a point, and species located at
    points can only be described in terms of amounts, not spatially-
    dependent measures such as concentration.  Since SBML KineticLaw
    formulas are already in terms of substance/time and not (say)
    concentration/time, volume or other factors in principle are not
    needed for species located in zero-dimensional compartments.

    Finally, in SBML Level 2 Versions 2-4, each compartment in a model may
    optionally be designated as belonging to a particular compartment
    type.  The optional attribute 'compartmentType' is used identify the
    compartment type represented by the Compartment structure. The
    'compartmentType' attribute's value must be the identifier of a
    CompartmentType instance defined in the model.  If the
    'compartmentType' attribute is not present on a particular compartment
    definition, a unique virtual compartment type is assumed for that
    compartment, and no other compartment can belong to that compartment
    type.  The values of 'compartmentType' attributes on compartments have
    no effect on the numerical interpretation of a model.  Simulators and
    other numerical analysis software may ignore 'compartmentType'
    attributes.  The 'compartmentType' attribute and the CompartmentType
    class of objects are not present in SBML Level 3 Core nor in SBML
    Level 1.

    Additional considerations in SBML Level 3
    ======================================================================

    One difference between SBML Level 3 and lower Levels of SBML is that
    there are no restrictions on the permissible values of the
    'spatialDimensions' attribute, and there is no default value defined
    for the attribute.  The value of 'spatialDimensions' does not have to
    be an integer, either; this is to allow for the possibility of
    representing structures with fractal dimensions.

    The number of spatial dimensions possessed by a compartment cannot
    enter into mathematical formulas, and therefore cannot directly alter
    the numerical interpretation of a model.  However, the value of
    'spatialDimensions' does affect the interpretation of the units
    associated with a compartment's size.  Specifically, the value of
    'spatialDimensions' is used to select among the Model attributes
    'volumeUnits', 'areaUnits' and 'lengthUnits' when a Compartment
    structure does not define a value for its 'units' attribute.

    The 'units' attribute may be left unspecified for a given compartment
    in a model; in that case, the compartment inherits the unit of
    measurement specified by one of the attributes on the enclosing Model
    object instance.  The applicable attribute on Model depends on the
    value of the compartment's 'spatialDimensions' attribute; the
    relationship is shown in the table below.  If the Model object does
    not define the relevant attribute ('volumeUnits', 'areaUnits' or
    'lengthUnits') for a given 'spatialDimensions' value, the unit
    associated with that Compartment object's size is undefined.  If a
    given Compartment's 'units' are left unset and  the
    'spatialDimensions' either has a value other than '1,' '2,' or  '3' or
    is left unset itself (as it has no default value), then no unit can be
    chosen from among the Model's 'volumeUnits', 'areaUnits' or
    'lengthUnits' attributes (even if the Model instance provides values
    for those attributes), because there is no basis to select between
    them. Leaving the units of compartments' sizes undefined in an SBML
    model does not render the model invalid; however, as a matter of best
    practice, we strongly recommend that all models specify the units of
    measurement for all compartment sizes.

      +----------------------------------------+-------------------------------------------------+-----------------------------------+
      | Value of attribute 'spatialDimensions' | Attribute of Model used for inheriting the unit | Recommended candidate units       |
      +----------------------------------------+-------------------------------------------------+-----------------------------------+
      | 3                                      | "volumeUnits"                                 | units of volume, or dimensionless |
      | 2                                      | "areaUnits"                                   | units of area, or dimensionless   |
      | 1                                      | "lengthUnits"                                 | units of length, or dimensionless |
      | other                                  | no units inherited                              | no specific recommendations       |
      +----------------------------------------+-------------------------------------------------+-----------------------------------+

    The unit of measurement associated with a compartment's size, as
    defined by the 'units' attribute or (if 'units' is not set) the
    inherited value from Model according to the table above, is used in
    the following ways:

    * When the identifier of the compartment appears as a numerical
    quantity in a mathematical formula expressed in MathML, it represents
    the size of the compartment, and the unit associated with the size is
    the value of the 'units' attribute.

    * When a Species is to be treated in terms of concentrations or
    density, the unit associated with the spatial size portion of the
    concentration value (i.e., the denominator in the formula amount/size)
    is specified by the value of the 'units' attribute on the compartment
    in which the species is located.

    * The 'math' elements of AssignmentRule, InitialAssignment and
    EventAssignment objects setting the value of the compartment size
    should all have the same units as the unit associated with the
    compartment's size.

    * In a RateRule object that defines a rate of change for a
    compartment's size, the unit of the rule's 'math' element should be
    identical to the compartment's 'units' attribute divided by the model-
    wide unit of time.  (In other words, {unit of compartment size}/{unit
    of time}.)

    Other aspects of Compartment
    ======================================================================

    In SBML Level 1 and Level 2, Compartment has an optional attribute
    named 'outside', whose value can be the identifier of another
    Compartment object defined in the enclosing Model object.  Doing so
    means that the other compartment contains it or is outside of it.
    This enables the representation of simple topological relationships
    between compartments, for those simulation systems that can make use
    of the information (e.g., for drawing simple diagrams of
    compartments).  It is worth noting that in SBML, there is no
    relationship between compartment sizes when compartment positioning is
    expressed using the 'outside' attribute.  The size of a given
    compartment does not in any sense include the sizes of other
    compartments having it as the value of their 'outside' attributes.  In
    other words, if a compartment B has the identifier of compartment A as
    its 'outside' attribute value, the size of A does not include the size
    of B.  The compartment sizes are separate.

    In Level 2, there are two restrictions on the 'outside' attribute.
    First, because a compartment with 'spatialDimensions' of '0' has no
    size, such a compartment cannot act as the container of any other
    compartment except compartments that also have 'spatialDimensions'
    values of '0.'  Second, the directed graph formed by representing
    Compartment structures as vertexes and the 'outside' attribute values
    as edges must be acyclic.  The latter condition is imposed to prevent
    a compartment from being contained inside itself.  In the absence of a
    value for 'outside', compartment definitions in SBML Level 2 do not
    have any implied spatial relationships between each other.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Compartment, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Compartment, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_Compartment
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(Compartment self, unsigned int level, unsigned int version) -> Compartment
        __init__(Compartment self, SBMLNamespaces sbmlns) -> Compartment
        __init__(Compartment self, Compartment orig) -> Compartment


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            Compartment(SBMLNamespaces sbmlns)

        Creates a new Compartment object using the given SBMLNamespaces object
        'sbmlns'.

        The SBMLNamespaces object encapsulates SBML Level/Version/namespaces
        information.  It is used to communicate the SBML Level, Version, and
        (in Level 3) packages used in addition to SBML Level 3 Core.  A common
        approach to using libSBML's SBMLNamespaces facilities is to create an
        SBMLNamespaces object somewhere in a program once, then hand that
        object as needed to object constructors that accept SBMLNamespaces as
        arguments.

        It is worth emphasizing that although this constructor does not take
        an identifier argument, in SBML Level 2 and beyond, the 'id'
        (identifier) attribute of a Compartment object is required to have a
        value.  Thus, callers are cautioned to assign a value after calling
        this constructor.  Setting the identifier can be accomplished using
        the method setId().

        Parameter 'sbmlns' is an SBMLNamespaces object.

        Throws SBMLConstructorException: Thrown if the given 'sbmlns' is
        inconsistent or incompatible with this object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            Compartment(long level, long version)

        Creates a new Compartment object using the given SBML 'level' and
        'version' values.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        Compartment.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this Compartment.

        Throws SBMLConstructorException: Thrown if the given 'level' and
        'version' combination are invalid or if this object is incompatible
        with the given level and version.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            Compartment(Compartment orig)

        Copy constructor.

        This creates a copy of a Compartment object.

        Parameter 'orig' is the Compartment instance to copy.

        """
        this = _libsbml.new_Compartment(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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


        Creates and returns a deep copy of this Compartment object.

        Returns the (deep) copy of this Compartment object.

        """
        return _libsbml.Compartment_clone(self)


    def initDefaults(self):
        """
        initDefaults(Compartment self)


        Initializes the fields of this Compartment object to 'typical' default
        values.

        The SBML Compartment component has slightly different aspects and
        default attribute values in different SBML Levels and Versions. This
        method sets the values to certain common defaults, based mostly on
        what they are in SBML Level 2.  Specifically:

        * Sets attribute 'spatialDimensions' to '3'

        * Sets attribute 'constant' to 'True'

        * (Applies to Level 1 models only) Sets attribute 'volume' to '1.0'

        * (Applies to Level 3 models only) Sets attribute 'units' to
        'litre'

        """
        return _libsbml.Compartment_initDefaults(self)


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


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

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is now recommended to use the
        getIdAttribute() function instead.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns the id of this Compartment.

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.Compartment_getId(self)


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


        Returns the value of the 'name' attribute of this Compartment object.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns the name of this SBML object, or the empty string if not set
        or unsettable.

        See also getIdAttribute(), isSetName(), setName(), unsetName().

        """
        return _libsbml.Compartment_getName(self)


    def getCompartmentType(self):
        """
        getCompartmentType(Compartment self) -> string


        Get the value of the 'compartmentType' attribute of this Compartment
        object.

        Returns the value of the 'compartmentType' attribute of this
        Compartment object as a string.

        Note: The 'compartmentType' attribute is only available in SBML Level
        2 Versions 2-4.

        See also isSetCompartmentType(), setCompartmentType(),
        unsetCompartmentType().

        """
        return _libsbml.Compartment_getCompartmentType(self)


    def getSpatialDimensions(self):
        """
        getSpatialDimensions(Compartment self) -> unsigned int


        Get the number of spatial dimensions of this Compartment object.

        Returns the value of the 'spatialDimensions' attribute of this
        Compartment object as a long integereger.

        Note: In SBML Level 3, the data type of the 'spatialDimensions'
        attribute is 'float,' whereas in Level 2, it is 'integer.'  To avoid
        backward compatibility issues, libSBML provides two separate methods
        for obtaining the value as either an integer or a type 'float,' for
        models where it is relevant.

        See also getSpatialDimensionsAsDouble(), setSpatialDimensions(),
        isSetSpatialDimensions(), unsetSpatialDimensions().

        """
        return _libsbml.Compartment_getSpatialDimensions(self)


    def getSpatialDimensionsAsDouble(self):
        """
        getSpatialDimensionsAsDouble(Compartment self) -> double


        Get the number of spatial dimensions of this Compartment object, as a
        double.

        Returns the value of the 'spatialDimensions' attribute of this
        Compartment object as a double, or 'NaN' if this model is not in SBML
        Level 3 format.

        Note: In SBML Level 3, the data type of the 'spatialDimensions'
        attribute is 'float,' whereas in Level 2, it is 'integer.'  To avoid
        backward compatibility issues, libSBML provides two separate methods
        for obtaining the value as either an integer or a type 'float,' for
        models where it is relevant.

        See also getSpatialDimensions(), setSpatialDimensions(),
        isSetSpatialDimensions(), unsetSpatialDimensions().

        """
        return _libsbml.Compartment_getSpatialDimensionsAsDouble(self)


    def getSize(self):
        """
        getSize(Compartment self) -> double


        Get the size of this Compartment object.

        In SBML Level 1, compartments are always three-dimensional constructs
        and only have volumes, whereas in SBML Level 2 and higher,
        compartments may be other than three-dimensional, and therefore the
        'volume' attribute is named 'size' in Level 2 and above.  LibSBML
        provides both getSize() and getVolume() for easier support of
        different SBML Levels.

        Returns the value of the 'size' attribute ('volume' in Level 1) of
        this Compartment object as a floating-point number.

        Note: This method is identical to getVolume().

        See also getVolume(), isSetSize(), setSize(), unsetSize().

        """
        return _libsbml.Compartment_getSize(self)


    def getVolume(self):
        """
        getVolume(Compartment self) -> double


        Get the volume of this Compartment object.

        In SBML Level 1, compartments are always three-dimensional constructs
        and only have volumes, whereas in SBML Level 2 and higher,
        compartments may be other than three-dimensional, and therefore the
        'volume' attribute is named 'size' in Level 2 and above.  LibSBML
        provides both getSize() and getVolume() for easier support of
        different SBML Levels.

        Returns the value of the 'volume' attribute ('size' in Level 2) of
        this Compartment object, as a floating-point number.

        Note: The attribute 'volume' only exists by that name in SBML Level 1.
        In Level 2 and above, the equivalent attribute is named 'size'.  In
        SBML Level 1, a compartment's volume has a default value ('1.0)' and
        therefore methods such as isSetVolume() will always return 'True' for
        a Level 1 model.  In Level 2, a compartment's size (the equivalent of
        SBML Level 1's 'volume') is optional and has no default value, and
        therefore may or may not be set.

        Note: This method is identical to getSize().

        See also getSize(), isSetVolume(), setVolume(), unsetVolume().

        """
        return _libsbml.Compartment_getVolume(self)


    def getUnits(self):
        """
        getUnits(Compartment self) -> string


        Get the units of this Compartment object's size.

        The value of an SBML compartment's 'units' attribute establishes the
        unit of measurement associated with the compartment's size.

        Returns the value of the 'units' attribute of this Compartment object,
        as a string.  An empty string indicates that no units have been
        assigned to the value of the size.

        Note: There is an important distinction to be made between no units
        assigned, and assuming a value without units has any specific unit
        such as dimensionless.  In SBML, default units are never attributed to
        numbers, and numbers without units are not automatically assumed to
        have the unit dimensionless.  Please consult the relevant SBML
        specification document for a more in-depth explanation of this topic
        and the SBML unit system.

        See also isSetUnits(), setUnits(), unsetUnits().

        """
        return _libsbml.Compartment_getUnits(self)


    def getOutside(self):
        """
        getOutside(Compartment self) -> string


        Get the identifier, if any, of the Compartment object that is
        designated as being outside of this one.

        Returns the value of the 'outside' attribute of this Compartment
        object.

        Note: The 'outside' attribute is defined in SBML Level 1 and Level 2,
        but does not exist in SBML Level 3.

        See also isSetOutside(), setOutside(), unsetOutside().

        """
        return _libsbml.Compartment_getOutside(self)


    def getConstant(self):
        """
        getConstant(Compartment self) -> bool


        Get the value of the 'constant' attribute of this Compartment object.

        Returns 'True' if this Compartment object's size is flagged as being
        constant, 'False' otherwise.

        See also isSetConstant(), setConstant().

        """
        return _libsbml.Compartment_getConstant(self)


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


        Predicate returning 'True' if this Compartment object's 'id' attribute
        is set.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns 'True' if the 'id' attribute of this SBML object is set,
        'False' otherwise.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is recommended that callers use
        isSetIdAttribute() instead.

        See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(),
        isSetIdAttribute().

        """
        return _libsbml.Compartment_isSetId(self)


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


        Predicate returning 'True' if this Compartment object's 'name'
        attribute is set.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns 'True' if the 'name' attribute of this SBML object is set,
        'False' otherwise.

        See also getName(), setName(), unsetName().

        """
        return _libsbml.Compartment_isSetName(self)


    def isSetCompartmentType(self):
        """
        isSetCompartmentType(Compartment self) -> bool


        Predicate returning 'True' if this Compartment object's
        'compartmentType' attribute is set.

        Returns 'True' if the 'compartmentType' attribute of this Compartment
        is set, 'False' otherwise.

        Note: The 'compartmentType' attribute is only available in SBML Level
        2 Versions 2-4.

        See also setCompartmentType(), getCompartmentType(),
        unsetCompartmentType().

        """
        return _libsbml.Compartment_isSetCompartmentType(self)


    def isSetSize(self):
        """
        isSetSize(Compartment self) -> bool


        Predicate returning 'True' if this Compartment object's 'size'
        attribute is set.

        This method is similar but not identical to isSetVolume().  The latter
        should be used in the context of SBML Level 1 models instead of
        isSetSize() because isSetVolume() performs extra processing to take
        into account the difference in default values between SBML Levels 1
        and 2.

        Returns 'True' if the 'size' attribute ('volume' in Level 2) of this
        Compartment object is set, 'False' otherwise.

        See also isSetVolume(), setSize(), getSize(), unsetSize().

        """
        return _libsbml.Compartment_isSetSize(self)


    def isSetVolume(self):
        """
        isSetVolume(Compartment self) -> bool


        Predicate returning 'True' if this Compartment object's 'volume'
        attribute is set.

        This method is similar but not identical to isSetSize().  The latter
        should not be used in the context of SBML Level 1 models because the
        present method performs extra processing to take into account the
        difference in default values between SBML Levels 1 and 2.

        Returns 'True' if the 'volume' attribute ('size' in Level 2 and above)
        of this Compartment object is set, 'False' otherwise.

        Note: The attribute 'volume' only exists by that name in SBML Level 1.
        In Level 2 and above, the equivalent attribute is named 'size'.  In
        SBML Level 1, a compartment's volume has a default value ('1.0)' and
        therefore methods such as isSetVolume() will always return 'True' for
        a Level 1 model.  In Level 2, a compartment's size (the equivalent of
        SBML Level 1's 'volume') is optional and has no default value, and
        therefore may or may not be set.

        See also isSetSize(), getVolume(), setVolume(), unsetVolume().

        """
        return _libsbml.Compartment_isSetVolume(self)


    def isSetUnits(self):
        """
        isSetUnits(Compartment self) -> bool


        Predicate returning 'True' if this Compartment object's 'units'
        attribute is set.

        Returns 'True' if the 'units' attribute of this Compartment object is
        set, 'False' otherwise.

        Note: There is an important distinction to be made between no units
        assigned, and assuming a value without units has any specific unit
        such as dimensionless.  In SBML, default units are never attributed to
        numbers, and numbers without units are not automatically assumed to
        have the unit dimensionless.  Please consult the relevant SBML
        specification document for a more in-depth explanation of this topic
        and the SBML unit system.

        See also setUnits(), getUnits(), unsetUnits().

        """
        return _libsbml.Compartment_isSetUnits(self)


    def isSetOutside(self):
        """
        isSetOutside(Compartment self) -> bool


        Predicate returning 'True' if this Compartment object's 'outside'
        attribute is set.

        Returns 'True' if the 'outside' attribute of this Compartment object
        is set, 'False' otherwise.

        Note: The 'outside' attribute is defined in SBML Level 1 and Level 2,
        but does not exist in SBML Level 3.

        See also getOutside(), setOutside(), unsetOutside().

        """
        return _libsbml.Compartment_isSetOutside(self)


    def isSetSpatialDimensions(self):
        """
        isSetSpatialDimensions(Compartment self) -> bool


        Predicate returning 'True' if this Compartment object's
        'spatialDimensions' attribute is set.

        Returns 'True' if the 'spatialDimensions' attribute of this
        Compartment object is set, 'False' otherwise.

        See also getSpatialDimensions(), setSpatialDimensions(),
        unsetSpatialDimensions().

        """
        return _libsbml.Compartment_isSetSpatialDimensions(self)


    def isSetConstant(self):
        """
        isSetConstant(Compartment self) -> bool


        Predicate returning 'True' if this Compartment object's 'constant'
        attribute is set.

        Returns 'True' if the 'constant' attribute of this Compartment object
        is set, 'False' otherwise.

        See also getConstant(), setConstant().

        """
        return _libsbml.Compartment_isSetConstant(self)


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


        Sets the value of the 'id' attribute of this Compartment object.

        The string 'sid' is copied.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Parameter 'sid' is the string to use as the identifier of this
        Compartment object. If the string is 'None,' this method will return
        LIBSBML_INVALID_ATTRIBUTE_VALUE.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        See also getId(), unsetId(), isSetId().

        """
        return _libsbml.Compartment_setId(self, sid)


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


        Sets the value of the 'name' attribute of this Compartment object.

        The string in 'name' is copied.

        Parameter 'name' is the new name for the SBML object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Compartment_setName(self, name)


    def setCompartmentType(self, sid):
        """
        setCompartmentType(Compartment self, string sid) -> int


        Sets the 'compartmentType' attribute of this Compartment object.

        Parameter 'sid' is the identifier of a CompartmentType object defined
        elsewhere in this Model. If the string is 'None,' this method will
        return LIBSBML_INVALID_ATTRIBUTE_VALUE.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        Note: The 'compartmentType' attribute is only available in SBML Level
        2 Versions 2-4.

        See also isSetCompartmentType(), getCompartmentType(),
        unsetCompartmentType().

        """
        return _libsbml.Compartment_setCompartmentType(self, sid)


    def setSpatialDimensions(self, *args):
        """
        setSpatialDimensions(Compartment self, unsigned int value) -> int
        setSpatialDimensions(Compartment self, double value) -> int


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            setSpatialDimensions(double value)

        Sets the 'spatialDimensions' attribute of this Compartment object as a
        double.

        Parameter 'value' is a double indicating the number of dimensions of
        this compartment.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        See also getSpatialDimensions(), isSetSpatialDimensions(),
        unsetSpatialDimensions().

        ______________________________________________________________________
        Method variant with the following signature:

            setSpatialDimensions(long value)

        Sets the 'spatialDimensions' attribute of this Compartment object.

        Parameter 'value' is a long integereger indicating the number of
        dimensions of this compartment.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        See also getSpatialDimensions(), isSetSpatialDimensions(),
        unsetSpatialDimensions().

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


    def setSize(self, value):
        """
        setSize(Compartment self, double value) -> int


        Sets the 'size' attribute (or 'volume' in SBML Level 1) of this
        Compartment object.

        Parameter 'value' is a 'float' representing the size of this
        compartment instance in whatever units are in effect for the
        compartment.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        Note: This method is identical to setVolume().

        See also setVolume(), getSize(), isSetSize(), unsetSize().

        """
        return _libsbml.Compartment_setSize(self, value)


    def setVolume(self, value):
        """
        setVolume(Compartment self, double value) -> int


        Sets the 'volume' attribute (or 'size' in SBML Level 2) of this
        Compartment object.

        This method is identical to setSize() and is provided for
        compatibility between SBML Level 1 and higher Levels of SBML.

        Parameter 'value' is a 'float' representing the volume of this
        compartment instance in whatever units are in effect for the
        compartment.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        Note: The attribute 'volume' only exists by that name in SBML Level 1.
        In Level 2 and above, the equivalent attribute is named 'size'.  In
        SBML Level 1, a compartment's volume has a default value ('1.0)' and
        therefore methods such as isSetVolume() will always return 'True' for
        a Level 1 model.  In Level 2, a compartment's size (the equivalent of
        SBML Level 1's 'volume') is optional and has no default value, and
        therefore may or may not be set.

        See also setSize(), getVolume(), isSetVolume(), unsetVolume().

        """
        return _libsbml.Compartment_setVolume(self, value)


    def setUnits(self, sid):
        """
        setUnits(Compartment self, string sid) -> int


        Sets the 'units' attribute of this Compartment object.

        Parameter 'sid' is the identifier of the defined units to use.  If
        'sid' is 'None,' then this method will return
        LIBSBML_INVALID_ATTRIBUTE_VALUE.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        See also isSetUnits(), getUnits(), unsetUnits().

        """
        return _libsbml.Compartment_setUnits(self, sid)


    def setOutside(self, sid):
        """
        setOutside(Compartment self, string sid) -> int


        Sets the 'outside' attribute of this Compartment object.

        Parameter 'sid' is the identifier of a compartment that encloses this
        one. If 'sid' is 'None,' then this method will return
        LIBSBML_INVALID_ATTRIBUTE_VALUE.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        Note: The 'outside' attribute is defined in SBML Level 1 and Level 2,
        but does not exist in SBML Level 3.

        See also isSetOutside(), getOutside(), unsetOutside().

        """
        return _libsbml.Compartment_setOutside(self, sid)


    def setConstant(self, value):
        """
        setConstant(Compartment self, bool value) -> int


        Sets the value of the 'constant' attribute of this Compartment object.

        Parameter 'value' is a boolean indicating whether the size/volume of
        this compartment should be considered constant ('True)' or variable
        ('False).'

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        See also isSetConstant(), getConstant().

        """
        return _libsbml.Compartment_setConstant(self, value)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(Compartment self, string oldid, string newid)


        Replaces all uses of a given 'SIdRef' type attribute value with
        another value.

        In SBML, object identifiers are of a data type called SId. In SBML
        Level 3, an explicit data type called SIdRef was introduced for
        attribute values that refer to SId values; in previous Levels of SBML,
        this data type did not exist and attributes were simply described to
        as 'referring to an identifier', but the effective data type was the
        same as SIdRef in Level 3.  These and other methods of libSBML refer
        to the type SIdRef for all Levels of SBML, even if the corresponding
        SBML specification did not explicitly name the data type.

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas in MathML content, comparing the referenced
        identifiers to the value of 'oldid'.  If any matches are found, the
        matching values are replaced with 'newid'.  The method does not
        descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.Compartment_renameSIdRefs(self, oldid, newid)


    def renameUnitSIdRefs(self, oldid, newid):
        """
        renameUnitSIdRefs(Compartment self, string oldid, string newid)


        Replaces all uses of a given 'UnitSIdRef' type attribute value with
        another value.

        In SBML, unit definitions have identifiers of type UnitSId.  In SBML
        Level 3, an explicit data type called UnitSIdRef was introduced for
        attribute values that refer to UnitSId values; in previous Levels of
        SBML, this data type did not exist and attributes were simply
        described to as 'referring to a unit identifier', but the effective
        data type was the same as UnitSIdRef in Level 3.  These and other
        methods of libSBML refer to the type UnitSIdRef for all Levels of
        SBML, even if the corresponding SBML specification did not explicitly
        name the data type.

        This method works by looking at all unit identifier attribute values
        (including, if appropriate, inside mathematical formulas), comparing
        the referenced unit identifiers to the value of 'oldid'.  If any
        matches are found, the matching values are replaced with 'newid'.  The
        method does not descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.Compartment_renameUnitSIdRefs(self, oldid, newid)


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


        Unsets the value of the 'name' attribute of this Compartment object.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getName(), setName(), isSetName().

        """
        return _libsbml.Compartment_unsetName(self)


    def unsetCompartmentType(self):
        """
        unsetCompartmentType(Compartment self) -> int


        Unsets the value of the 'compartmentType' attribute of this
        Compartment object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        Note: The 'compartmentType' attribute is only available in SBML Level
        2 Versions 2-4.

        See also setCompartmentType(), isSetCompartmentType(),
        getCompartmentType().

        """
        return _libsbml.Compartment_unsetCompartmentType(self)


    def unsetConstant(self):
        """
        unsetConstant(Compartment self) -> int


        Unsets the value of the 'constant' attribute of this Compartment
        object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also isSetConstant(), setConstant(), getConstant().

        """
        return _libsbml.Compartment_unsetConstant(self)


    def unsetSize(self):
        """
        unsetSize(Compartment self) -> int


        Unsets the value of the 'size' attribute of this Compartment object.

        In SBML Level 1, a compartment's volume has a default value ('1.0)'
        and therefore should always be set.  Calling this method on a Level 1
        model resets the value to '1.0' rather than actually unsetting it.  In
        Level 2, a compartment's 'size' is optional with no default value, and
        unsetting it will result in the compartment having no defined size.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        Note: This method is identical to unsetVolume().

        See also unsetVolume(), getSize(), isSetSize(), setSize().

        """
        return _libsbml.Compartment_unsetSize(self)


    def unsetVolume(self):
        """
        unsetVolume(Compartment self) -> int


        Unsets the value of the 'volume' attribute of this Compartment object.

        This method is identical to unsetSize().  Please refer to that
        method's documentation for more information about its behavior.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        Note: The attribute 'volume' only exists by that name in SBML Level 1.
        In Level 2 and above, the equivalent attribute is named 'size'.  In
        SBML Level 1, a compartment's volume has a default value ('1.0)' and
        therefore methods such as isSetVolume() will always return 'True' for
        a Level 1 model.  In Level 2, a compartment's size (the equivalent of
        SBML Level 1's 'volume') is optional and has no default value, and
        therefore may or may not be set.

        See also unsetSize(), getVolume(), setVolume(), isSetVolume().

        """
        return _libsbml.Compartment_unsetVolume(self)


    def unsetUnits(self):
        """
        unsetUnits(Compartment self) -> int


        Unsets the value of the 'units' attribute of this Compartment object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also isSetUnits(), setUnits(), getUnits().

        """
        return _libsbml.Compartment_unsetUnits(self)


    def unsetOutside(self):
        """
        unsetOutside(Compartment self) -> int


        Unsets the value of the 'outside' attribute of this Compartment
        object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        Note: The 'outside' attribute is defined in SBML Level 1 and Level 2,
        but does not exist in SBML Level 3.

        See also isSetOutside(), getOutside(), setOutside().

        """
        return _libsbml.Compartment_unsetOutside(self)


    def unsetSpatialDimensions(self):
        """
        unsetSpatialDimensions(Compartment self) -> int


        Unsets the value of the 'spatialDimensions' attribute of this
        Compartment object.

        In SBML Levels prior to Level 3, compartments must always have a value
        for the number of dimensions.  Consequently, calling this method on a
        model of SBML Level 1-2 will result in a return value of
        LIBSBML_UNEXPECTED_ATTRIBUTE

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        Note: This function is only valid for SBML Level 3.

        See also getSpatialDimensions(), isSetSpatialDimensions(),
        setSpatialDimensions().

        """
        return _libsbml.Compartment_unsetSpatialDimensions(self)


    def getDerivedUnitDefinition(self, *args):
        """
        getDerivedUnitDefinition(Compartment self) -> UnitDefinition
        getDerivedUnitDefinition(Compartment self) -> UnitDefinition


        Constructs and returns a UnitDefinition that corresponds to the units
        of this Compartment object's designated size.

        Compartments in SBML have an attribute ('units') for declaring the
        units of measurement intended for the value of the compartment's size.
        In the absence of a value given for this attribute, the units are
        inherited from values either defined on the enclosing Model (in SBML
        Level 3) or in defaults (in SBML Level 2).  This method returns a
        UnitDefinition object based on how this compartment's units are
        interpreted according to the relevant SBML guidelines, or it returns
        'None' if no units have been declared and no defaults are defined by
        the relevant SBML specification.

        Note that unit declarations for Compartment objects  are specified in
        terms of the identifier of a unit, but this method returns an object ,
        not a unit identifier.  It does this by constructing an appropriate
        UnitDefinition object.  For SBML Level 2 models, it will do this even
        when the value of the 'units' attribute is one of the special SBML
        Level 2 unit identifiers ''substance',' ''volume',' ''area','
        ''length'' or ''time'.'  Callers may find this useful in conjunction
        with the helper methods provided by the UnitDefinition class for
        comparing different UnitDefinition objects.

        Returns a UnitDefinition that expresses the units of this Compartment
        object, or 'None' if one cannot be constructed.

        Note: The libSBML system for unit analysis depends on the model as a
        whole.  In cases where the Compartment object has not yet been added
        to a model, or the model itself is incomplete, unit analysis is not
        possible, and consequently this method will return 'None.'

        See also isSetUnits(), getUnits().

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


    def getTypeCode(self):
        """
        getTypeCode(Compartment self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_COMPARTMENT
        (default).

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.Compartment_getTypeCode(self)


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


        Returns the XML element name of this object

        For Compartment, the XML element name is always ''compartment'.'

        Returns the name of this element.

        """
        return _libsbml.Compartment_getElementName(self)


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


        Predicate returning 'True' if all the required attributes for this
        Compartment object have been set.

        The required attributes for a Compartment object are:

        * 'id' (or 'name' in SBML Level 1)

        * 'constant' (in SBML Level 3 only)

        Returns 'True' if the required attributes have been set, 'False'
        otherwise.

        """
        return _libsbml.Compartment_hasRequiredAttributes(self)

Compartment_swigregister = _libsbml.Compartment_swigregister
Compartment_swigregister(Compartment)

class ListOfCompartments(ListOf):
    """

    A list of Compartment objects.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfCompartments, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfCompartments, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ListOfCompartments self, unsigned int level, unsigned int version) -> ListOfCompartments
        __init__(ListOfCompartments self, SBMLNamespaces sbmlns) -> ListOfCompartments


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfCompartments(SBMLNamespaces sbmlns)

        Creates a new ListOfCompartments object.

        The object is constructed such that it is valid for the SBML Level and
        Version combination determined by the SBMLNamespaces object in
        'sbmlns'.

        Parameter 'sbmlns' is an SBMLNamespaces object that is used to
        determine the characteristics of the ListOfCompartments object to be
        created.

        Throws SBMLConstructorException: Thrown if the given 'sbmlns' is
        inconsistent or incompatible with this object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfCompartments(long level, long version)

        Creates a new ListOfCompartments object.

        The object is constructed such that it is valid for the given SBML
        Level and Version combination.

        Parameter 'level' is the SBML Level.

        Parameter 'version' is the Version within the SBML Level.

        Throws SBMLConstructorException: Thrown if the given 'level' and
        'version' combination are invalid or if this object is incompatible
        with the given level and version.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        """
        this = _libsbml.new_ListOfCompartments(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ListOfCompartments self) -> ListOfCompartments


        Creates and returns a deep copy of this ListOfCompartments object.

        Returns the (deep) copy of this ListOfCompartments object.

        """
        return _libsbml.ListOfCompartments_clone(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfCompartments self) -> int


        Returns the libSBML type code for the objects contained in this ListOf
        (i.e., Compartment objects, if the list is non-empty).

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for the objects contained in this ListOf
        instance: SBML_COMPARTMENT (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfCompartments_getItemTypeCode(self)


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


        Returns the XML element name of this object.

        For ListOfCompartments, the XML element name is always
        ''listOfCompartments'.'

        Returns the name of this element.

        """
        return _libsbml.ListOfCompartments_getElementName(self)


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a Compartment object from the ListOfCompartments.

        Parameter 'n' is the index number of the Compartment object to get.

        Returns the nth Compartment object in this ListOfCompartments. If the
        index 'n' is invalid, 'None' is returned.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a Compartment object from the ListOfCompartments based on its
        identifier.

        Parameter 'sid' is a string representing the identifier of the
        Compartment object to get.

        Returns Compartment object in this ListOfCompartments with the given
        'sid' or 'None' if no such Compartment object exists.

        See also get(), size().

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


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth item from this ListOfCompartments items and returns a
        pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the item to remove.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes item in this ListOfCompartments 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 'sid', then
        'None' is returned.

        Parameter 'sid' is the identifier of the item to remove.

        Returns the item removed.  As mentioned above, the caller owns the
        returned item.

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

    __swig_destroy__ = _libsbml.delete_ListOfCompartments
    __del__ = lambda self: None
ListOfCompartments_swigregister = _libsbml.ListOfCompartments_swigregister
ListOfCompartments_swigregister(ListOfCompartments)

class Species(SBase):
    """

    An SBML species - a pool of entities.

    A species in SBML refers to a pool of entities that (a) are considered
    indistinguishable from each other for the purposes of the model, (b)
    participate in reactions, and (c) are located in a specific
    compartment.  The SBML Species object class is intended to represent
    these pools.

    As with other major constructs in SBML, Species has a mandatory
    attribute, 'id', used to give the species type an identifier in the
    model.  The identifier must be a text string conforming to the
    identifer syntax permitted in SBML.  Species also has an optional
    'name' attribute, of type 'string.'  The 'id' and 'name' must be used
    according to the guidelines described in the SBML specifications.

    The required attribute 'compartment' is used to identify the
    compartment in which the species is located.  The attribute's value
    must be the identifier of an existing Compartment object.  It is
    important to note that there is no default value for the 'compartment'
    attribute on Species; every species in an SBML model must be assigned
    a compartment explicitly.  (This also implies that every model with
    one or more Species objects must define at least one Compartment
    object.)

    The initial amount and concentration of a species
    ======================================================================

    The optional attributes 'initialAmount' and 'initialConcentration',
    both having a data type of 'float,' can be used to set the initial
    quantity of the species in the compartment where the species is
    located. These attributes are mutually exclusive; i.e., only one can
    have a value on any given instance of a Species object.  Missing
    'initialAmount' and 'initialConcentration' values implies that their
    values either are unknown, or to be obtained from an external source,
    or determined by an InitialAssignment or other SBML construct
    elsewhere in the model.

    A species' initial quantity in SBML is set by the 'initialAmount' or
    'initialConcentration' attribute exactly once.  If the 'constant'
    attribute is 'True,' then the value of the species' quantity is fixed
    and cannot be changed except by an InitialAssignment.  These methods
    differ in that the 'initialAmount' and 'initialConcentration'
    attributes can only be used to set the species quantity to a literal
    floating-point number, whereas the use of an InitialAssignment object
    allows the value to be set using an arbitrary mathematical expression
    (which, thanks to MathML's expressiveness, may evaluate to a rational
    number).  If the species' 'constant' attribute is 'False,' the
    species' quantity value may be overridden by an InitialAssignment or
    changed by AssignmentRule or AlgebraicRule, and in addition, for t >
    0, it may also be changed by a RateRule, Event objects, and as a
    result of being a reactant or product in one or more Reaction objects.
    (However, some constructs are mutually exclusive; see the SBML
    specifications for the precise details.)  It is not an error to define
    'initialAmount' or 'initialConcentration' on a species and also
    redefine the value using an InitialAssignment, but the 'initialAmount'
    or 'initialConcentration' setting in that case is ignored.  The SBML
    specifications provide additional information about the semantics of
    assignments, rules and values for simulation time t <= 0.

    SBML Level 2 additionally stipulates that in cases where a species'
    compartment has a 'spatialDimensions' value of '0' (zero), the species
    cannot have a value for 'initialConcentration' because the concepts of
    concentration and density break down when a container has zero
    dimensions.

    The units of a species' amount or concentration
    ======================================================================

    When the attribute 'initialAmount' is set, the unit of measurement
    associated with the value of 'initialAmount' is specified by the
    Species attribute 'substanceUnits'.  When the 'initialConcentration'
    attribute is set, the unit of measurement associated with this
    concentration value is {unit of amount} divided by {unit of size},
    where the {unit of amount} is specified by the Species
    'substanceUnits' attribute, and the {unit of size} is specified by the
    'units' attribute of the Compartment object in which the species is
    located.  Note that in either case, a unit of amount is involved and
    determined by the 'substanceUnits' attribute.  Note these two
    attributes alone do not determine the units of the species when the
    species identifier appears in a mathematical expression; that aspect
    is determined by the attribute 'hasOnlySubstanceUnits' discussed
    below.

    In SBML Level 3, if the 'substanceUnits' attribute is not set on a
    given Species object instance, then the unit of amount for that
    species is inherited from the 'substanceUnits' attribute on the
    enclosing Model object instance.  If that attribute on Model is not
    set either, then the unit associated with the species' quantity is
    undefined.

    In SBML Level 2, if the 'substanceUnits' attribute is not set on a
    given Species object instance, then the unit of amount for that
    species is taken from the predefined SBML unit identifier
    ''substance'.'  The value assigned to 'substanceUnits' must be chosen
    from one of the following possibilities: one of the base unit
    identifiers defined in SBML, the built-in unit identifier
    ''substance',' or the identifier of a new unit defined in the list of
    unit definitions in the enclosing Model object.  The chosen units for
    'substanceUnits' must be be ''dimensionless',' ''mole',' ''item','
    ''kilogram',' ''gram',' or units derived from these.

    As noted at the beginning of this section, simply setting
    'initialAmount' or 'initialConcentration' alone does not determine
    whether a species identifier represents an amount or a concentration
    when it appears elsewhere in an SBML model.  The role of the attribute
    'hasOnlySubstanceUnits' is to indicate whether the units of the
    species, when the species identifier appears in mathematical formulas,
    are intended to be concentration or amount.  The attribute takes on a
    boolean value.  In SBML Level 3, the attribute has no default value
    and must always be set in a model; in SBML Level 2, it has a default
    value of 'False.'

    The units of the species are used in the following ways:

    * When the species' identifier appears in a MathML formula, it
    represents the species' quantity, and the unit of measurement
    associated with the quantity is as described above.

    * The 'math' elements of AssignmentRule, InitialAssignment and
    EventAssignment objects referring to this species should all have the
    same units as the unit of measurement associated with the species
    quantity.

    * In a RateRule object that defines the rate of change of the species'
    quantity, the unit associated with the rule's 'math' element should be
    equal to the unit of the species' quantity divided by the model-wide
    unit of time; in other words, {unit of species quantity}/{unit of
    time}.

    The 'constant' and 'boundaryCondition' attributes
    ======================================================================

    The Species object class has two boolean attributes named 'constant'
    and 'boundaryCondition', used to indicate whether and how the quantity
    of that species can vary during a simulation.  In SBML Level 2 they
    are optional; in SBML Level 3 they are mandatory.  The following table
    shows how to interpret the combined values of these attributes.

      +----------------+-------------------------+-----------------------------------+-----------------------------+----------------------------------------------------------------+
      | constant value | boundaryCondition value | Can have assignment or rate rule? | Can be reactant or product? | Species' quantity can be changed by                            |
      +----------------+-------------------------+-----------------------------------+-----------------------------+----------------------------------------------------------------+
      | true           | true                    | no                                | yes                         | (never changes)                                                |
      | false          | true                    | yes                               | yes                         | rules and events                                               |
      | true           | false                   | no                                | no                          | (never changes)                                                |
      | false          | false                   | yes                               | yes                         | reactions or rules (but not both at the same time), and events |
      +----------------+-------------------------+-----------------------------------+-----------------------------+----------------------------------------------------------------+

    By default, when a species is a product or reactant of one or more
    reactions, its quantity is determined by those reactions.  In SBML, it
    is possible to indicate that a given species' quantity is not
    determined by the set of reactions even when that species occurs as a
    product or reactant; i.e., the species is on the boundary of the
    reaction system, and its quantity is not determined by the reactions.
    The boolean attribute 'boundaryCondition' can be used to indicate
    this.  A value of 'False' indicates that the species is part of the
    reaction system.  In SBML Level 2, the attribute has a default value
    of 'False,' while in SBML Level 3, it has no default.

    The 'constant' attribute indicates whether the species' quantity can
    be changed at all, regardless of whether by reactions, rules, or
    constructs other than InitialAssignment.  A value of 'False' indicates
    that the species' quantity can be changed.  (This is also a common
    value because the purpose of most simulations is precisely to
    calculate changes in species quantities.)  In SBML Level 2, the
    attribute has a default value of 'False,' while in SBML Level 3, it
    has no default.  Note that the initial quantity of a species can be
    set by an InitialAssignment irrespective of the value of the
    'constant' attribute.

    In practice, a 'boundaryCondition' value of 'True' means a
    differential equation derived from the reaction definitions should not
    be generated for the species.  However, the species' quantity may
    still be changed by AssignmentRule, RateRule, AlgebraicRule, Event,
    and InitialAssignment constructs if its 'constant' attribute is
    'False.'  Conversely, if the species' 'constant' attribute is 'True,'
    then its value cannot be changed by anything except InitialAssignment.

    A species having 'boundaryCondition'='False' and 'constant'='False'
    can appear as a product and/or reactant of one or more reactions in
    the model.  If the species is a reactant or product of a reaction, it
    must not also appear as the target of any AssignmentRule or RateRule
    object in the model.  If instead the species has 'boundaryCondition'=
    'False' and 'constant'='True,' then it cannot appear as a reactant or
    product, or as the target of any AssignmentRule, RateRule or
    EventAssignment object in the model.

    Finally, it is worth clarifying that while the constant and
    boundaryCondition attributes restrict whether and how the species
    amount changes, the same is not true of a species' concentration. In
    SBML, the concentration of a species is a quantity that depends on the
    size of the compartment in which it is located. A compartment's size
    may change, and therefore, so can the concentration of a species even
    if the amount of the species remains unchanged. A species'
    concentration  may therefore vary even if the Species object's
    constant attribute is  set to 'True' in a model.

    The conversionFactor attribute in SBML Level 3
    ======================================================================

    In SBML Level 3, Species has an additional optional attribute,
    'conversionFactor', that defines a conversion factor that applies to a
    particular species.  The value must be the identifier of a Parameter
    object instance defined in the model.  That Parameter object must be a
    constant, meaning its 'constant' attribute must be set to 'True.' If a
    given Species object definition defines a value for its
    'conversionFactor' attribute, it takes precedence over any factor
    defined by the Model object's 'conversionFactor' attribute.

    The unit of measurement associated with a species' quantity can be
    different from the unit of extent of reactions in the model.  SBML
    Level 3 avoids implicit unit conversions by providing an explicit way
    to indicate any unit conversion that might be required.  The use of a
    conversion factor in computing the effects of reactions on a species'
    quantity is explained in detail in the SBML Level 3 specification
    document.  Because the value of the 'conversionFactor' attribute is
    the identifier of a Parameter object, and because parameters can have
    units attached to them, the transformation from reaction extent units
    to species units can be completely specified using this approach.

    Note that the unit conversion factor is only applied when calculating
    the effect of a reaction on a species.  It is not used in any rules or
    other SBML constructs that affect the species, and it is also not used
    when the value of the species is referenced in a mathematical
    expression.

    The speciesType attribute in SBML Level 2 Versions 2-4
    ======================================================================

    In SBML Level 2 Versions 2-4, each species in a model may optionally
    be designated as belonging to a particular species type. The optional
    attribute 'speciesType' is used to identify the species type of the
    chemical entities that make up the pool represented by the Species
    objects.  The attribute's value must be the identifier of an existing
    SpeciesType object in the model.  If the 'speciesType' attribute is
    not present on a particular species definition, it means the pool
    contains chemical entities of a type unique to that pool; in effect, a
    virtual species type is assumed for that species, and no other species
    can belong to that species type.  The value of 'speciesType'
    attributes on species have no effect on the numerical interpretation
    of a model; simulators and other numerical analysis software may
    ignore 'speciesType' attributes.

    There can be only one species of a given species type in any given
    compartment of a model.  More specifically, for all Species objects
    having a value for the 'speciesType' attribute, the pair <center>
    ('speciesType' attribute value, 'compartment' attribute value)
    </center>

    must be unique across the set of all Species object in a model.

    The spatialSizeUnits attribute in SBML Level 2 Versions 1-2
    ======================================================================

    In versions of SBML Level 2 before Version 3, the class Species
    included an attribute called 'spatialSizeUnits', which allowed
    explicitly setting the units of size for initial concentration.
    LibSBML retains this attribute for compatibility with older
    definitions of Level 2, but its use is strongly discouraged because
    many software tools do no properly interpret this unit declaration and
    it is incompatible with all SBML specifications after Level 2 Version
    3.

    Additional considerations for interpreting the numerical value of a
    species
    ======================================================================

    Species are unique in SBML in that they have a kind of duality: a
    species identifier may stand for either substance amount (meaning, a
    count of the number of individual entities) or a concentration or
    density (meaning, amount divided by a compartment size).  The previous
    sections explain the meaning of a species identifier when it is
    referenced in a mathematical formula or in rules or other SBML
    constructs; however, it remains to specify what happens to a species
    when the compartment in which it is located changes in size.

    When a species definition has a 'hasOnlySubstanceUnits' attribute
    value of 'False' and the size of the compartment in which the species
    is located changes, the default in SBML is to assume that it is the
    concentration that must be updated to account for the size change.
    This follows from the principle that, all other things held constant,
    if a compartment simply changes in size, the size change does not in
    itself cause an increase or decrease in the number of entities of any
    species in that compartment.  In a sense, the default is that the
    amount of a species is preserved across compartment size changes.
    Upon such size changes, the value of the concentration or density must
    be recalculated from the simple relationship concentration = amount /
    size if the value of the concentration is needed (for example, if the
    species identifier appears in a mathematical formula or is otherwise
    referenced in an SBML construct).  There is one exception: if the
    species' quantity is determined by an AssignmentRule, RateRule,
    AlgebraicRule, or an EventAssignment and the species has a
    'hasOnlySubstanceUnits' attribute value of 'False,' it means that the
    concentration is assigned by the rule or event; in that case, the
    amount must be calculated when the compartment size changes.  (Events
    also require additional care in this situation, because an event with
    multiple assignments could conceivably reassign both a species
    quantity and a compartment size simultaneously.  Please refer to the
    SBML specifications for the details.)

    Note that the above only matters if a species has a
    'hasOnlySubstanceUnits' attribute value of 'False,' meaning that the
    species identifier refers to a concentration wherever the identifier
    appears in a mathematical formula.  If instead the attribute's value
    is 'True,' then the identifier of the species always stands for an
    amount wherever it appears in a mathematical formula or is referenced
    by an SBML construct.  In that case, there is never a question about
    whether an assignment or event is meant to affect the amount or
    concentration: it is always the amount.

    A particularly confusing situation can occur when the species has
    'constant' attribute value of 'True' in combination with a
    'hasOnlySubstanceUnits' attribute value of 'False.'  Suppose this
    species is given a value for 'initialConcentration'.  Does a
    'constant' value of 'True' mean that the concentration is held
    constant if the compartment size changes?  No; it is still the amount
    that is kept constant across a compartment size change.  The fact that
    the species was initialized using a concentration value is irrelevant.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Species, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Species, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_Species
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(Species self, unsigned int level, unsigned int version) -> Species
        __init__(Species self, SBMLNamespaces sbmlns) -> Species
        __init__(Species self, Species orig) -> Species


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            Species(SBMLNamespaces sbmlns)

        Creates a new Species using the given SBMLNamespaces object 'sbmlns'.

        The SBMLNamespaces object encapsulates SBML Level/Version/namespaces
        information.  It is used to communicate the SBML Level, Version, and
        (in Level 3) packages used in addition to SBML Level 3 Core.  A common
        approach to using libSBML's SBMLNamespaces facilities is to create an
        SBMLNamespaces object somewhere in a program once, then hand that
        object as needed to object constructors that accept SBMLNamespaces as
        arguments.

        It is worth emphasizing that although this constructor does not take
        an identifier argument, in SBML Level 2 and beyond, the 'id'
        (identifier) attribute of a Species is required to have a value. Thus,
        callers are cautioned to assign a value after calling this
        constructor.  Setting the identifier can be accomplished using the
        method Species.setId().

        Parameter 'sbmlns' is an SBMLNamespaces object.

        Throws SBMLConstructorException: Thrown if the given 'sbmlns' is
        inconsistent or incompatible with this object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            Species(long level, long version)

        Creates a new Species using the given SBML 'level' and 'version'
        values.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        Species.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this Species.

        Throws SBMLConstructorException: Thrown if the given 'level' and
        'version' combination are invalid or if this object is incompatible
        with the given level and version.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            Species(Species orig)

        Copy constructor; creates a copy of this Species object.

        Parameter 'orig' is the object to copy.

        """
        this = _libsbml.new_Species(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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


        Creates and returns a deep copy of this Species object.

        Returns the (deep) copy of this Species object.

        """
        return _libsbml.Species_clone(self)


    def initDefaults(self):
        """
        initDefaults(Species self)


        Initializes the fields of this Species object to 'typical' defaults
        values.

        The SBML Species component has slightly different aspects and default
        attribute values in different SBML Levels and Versions. This method
        sets the values to certain common defaults, based mostly on what they
        are in SBML Level 2.  Specifically:

        * Sets 'boundaryCondition' to 'False'

        * Sets 'constant' to 'False'

        * sets 'hasOnlySubstanceUnits' to 'False'

        * (Applies to Level 3 models only) Sets attribute 'substanceUnits'
        to 'mole'

        """
        return _libsbml.Species_initDefaults(self)


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


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

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is now recommended to use the
        getIdAttribute() function instead.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns the id of this Species.

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.Species_getId(self)


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


        Returns the value of the 'name' attribute of this Species object.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns the name of this SBML object, or the empty string if not set
        or unsettable.

        See also getIdAttribute(), isSetName(), setName(), unsetName().

        """
        return _libsbml.Species_getName(self)


    def getSpeciesType(self):
        """
        getSpeciesType(Species self) -> string


        Get the type of this Species object object.

        Returns the value of the 'speciesType' attribute of this Species as a
        string.

        Note: The 'speciesType' attribute is only available in SBML Level 2
        Versions 2-4.

        """
        return _libsbml.Species_getSpeciesType(self)


    def getCompartment(self):
        """
        getCompartment(Species self) -> string


        Get the compartment in which this species is located.

        The compartment is designated by its identifier.

        Returns the value of the 'compartment' attribute of this Species
        object, as a string.

        """
        return _libsbml.Species_getCompartment(self)


    def getInitialAmount(self):
        """
        getInitialAmount(Species self) -> double


        Get the value of the 'initialAmount' attribute.

        Returns the initialAmount of this Species, as a floating point number.

        """
        return _libsbml.Species_getInitialAmount(self)


    def getInitialConcentration(self):
        """
        getInitialConcentration(Species self) -> double


        Get the value of the 'initialConcentration' attribute.

        Returns the initialConcentration of this Species,, as a floating point
        number.

        Note: The attribute 'initialConcentration' is only available in SBML
        Level 2 and 3.  It does not exist on Species in Level 1.

        """
        return _libsbml.Species_getInitialConcentration(self)


    def getSubstanceUnits(self):
        """
        getSubstanceUnits(Species self) -> string


        Get the value of the 'substanceUnits' attribute.

        Returns the value of the 'substanceUnits' attribute of this Species,
        as a string.  An empty string indicates that no units have been
        assigned.

        Note: There is an important distinction to be made between no units
        assigned, and assuming a value without units has any specific unit
        such as dimensionless.  In SBML, default units are never attributed to
        numbers, and numbers without units are not automatically assumed to
        have the unit dimensionless.  Please consult the relevant SBML
        specification document for a more in-depth explanation of this topic
        and the SBML unit system.

        See also isSetSubstanceUnits(), setSubstanceUnits().

        """
        return _libsbml.Species_getSubstanceUnits(self)


    def getSpatialSizeUnits(self):
        """
        getSpatialSizeUnits(Species self) -> string


        Get the value of the 'spatialSizeUnits' attribute.

        Returns the value of the 'spatialSizeUnits' attribute of this Species
        object, as a string.

        WARNING:

        In versions of SBML Level 2 before Version 3, the class Species
        included an attribute called 'spatialSizeUnits', which allowed
        explicitly setting the units of size for initial concentration.  This
        attribute was removed in SBML Level 2 Version 3.  LibSBML retains this
        attribute for compatibility with older definitions of Level 2, but its
        use is strongly discouraged because it is incompatible with levels and
        versions of SBML beyond Level 2 Version 2.

        """
        return _libsbml.Species_getSpatialSizeUnits(self)


    def getUnits(self):
        """
        getUnits(Species self) -> string


        Get the value of the 'units' attribute.

        Returns the units of this Species (L1 only).

        Note: The 'units' attribute is defined only in SBML Level 1.  In SBML
        Level 2 and Level 3, it has been replaced by a combination of
        'substanceUnits' and the units of the Compartment object in which a
        species is located.  In SBML Level 2 Versions 1-2, an additional
        attribute 'spatialSizeUnits' helps determine the units of the species
        quantity, but this attribute was removed in later versions of SBML
        Level 2.

        """
        return _libsbml.Species_getUnits(self)


    def getHasOnlySubstanceUnits(self):
        """
        getHasOnlySubstanceUnits(Species self) -> bool


        Get the value of the 'hasOnlySubstanceUnits' attribute.

        Returns 'True' if this Species' 'hasOnlySubstanceUnits' attribute
        value is 'True,' 'False' otherwise.

        Note: The 'hasOnlySubstanceUnits' attribute does not exist in SBML
        Level 1.

        """
        return _libsbml.Species_getHasOnlySubstanceUnits(self)


    def getBoundaryCondition(self):
        """
        getBoundaryCondition(Species self) -> bool


        Get the value of the 'boundaryCondition' attribute.

        Returns 'True' if this Species' 'boundaryCondition' attribute value is
        'True,' 'False' otherwise.

        """
        return _libsbml.Species_getBoundaryCondition(self)


    def getCharge(self):
        """
        getCharge(Species self) -> int


        Get the value of the 'charge' attribute.

        Returns the charge of this Species object.

        Note: Beginning in SBML Level 2 Version 2, the 'charge' attribute on
        Species is deprecated and in SBML Level 3 it does not exist at all.
        Its use strongly discouraged.  Its presence is considered a misfeature
        in earlier definitions of SBML because its implications for the
        mathematics of a model were never defined, and in any case, no known
        modeling system ever used it.  Instead, models take account of charge
        values directly in their definitions of species by (for example)
        having separate species identities for the charged and uncharged
        versions of the same species.  This allows the condition to affect
        model mathematics directly.  LibSBML retains this method for easier
        compatibility with SBML Level 1.

        """
        return _libsbml.Species_getCharge(self)


    def getConstant(self):
        """
        getConstant(Species self) -> bool


        Get the value of the 'constant' attribute.

        Returns 'True' if this Species's 'constant' attribute value is 'True,'
        'False' otherwise.

        Note: The attribute 'constant' is only available in SBML Levels 2 and
        3.  It does not exist on Species in Level 1.

        """
        return _libsbml.Species_getConstant(self)


    def getConversionFactor(self):
        """
        getConversionFactor(Species self) -> string


        Get the value of the 'conversionFactor' attribute.

        Returns the conversionFactor of this Species, as a string.

        Note: The 'conversionFactor' attribute was introduced in SBML Level 3.
        It does not exist on Species in SBML Levels 1 and 2.

        """
        return _libsbml.Species_getConversionFactor(self)


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


        Predicate returning 'True' if this Species object's 'id' attribute is
        set.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns 'True' if the 'id' attribute of this SBML object is set,
        'False' otherwise.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is recommended that callers use
        isSetIdAttribute() instead.

        See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(),
        isSetIdAttribute().

        """
        return _libsbml.Species_isSetId(self)


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


        Predicate returning 'True' if this Species object's 'name' attribute
        is set.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns 'True' if the 'name' attribute of this SBML object is set,
        'False' otherwise.

        See also getName(), setName(), unsetName().

        """
        return _libsbml.Species_isSetName(self)


    def isSetSpeciesType(self):
        """
        isSetSpeciesType(Species self) -> bool


        Predicate returning 'True' if this Species object's 'speciesType'
        attribute is set.

        Returns 'True' if the 'speciesType' attribute of this Species is set,
        'False' otherwise.

        Note: The 'speciesType' attribute is only available in SBML Level 2
        Versions 2-4.

        """
        return _libsbml.Species_isSetSpeciesType(self)


    def isSetCompartment(self):
        """
        isSetCompartment(Species self) -> bool


        Predicate returning 'True' if this Species object's 'compartment'
        attribute is set.

        Returns 'True' if the 'compartment' attribute of this Species is set,
        'False' otherwise.

        """
        return _libsbml.Species_isSetCompartment(self)


    def isSetInitialAmount(self):
        """
        isSetInitialAmount(Species self) -> bool


        Predicate returning 'True' if this Species object's 'initialAmount'
        attribute is set.

        Returns 'True' if the 'initialAmount' attribute of this Species is
        set, 'False' otherwise.

        Note: In SBML Level 1, Species' 'initialAmount' is required and
        therefore should always be set.  (However, in Level 1, the attribute
        has no default value either, so this method will not return 'True'
        until a value has been assigned.)  In SBML Level 2, 'initialAmount' is
        optional and as such may or may not be set.

        """
        return _libsbml.Species_isSetInitialAmount(self)


    def isSetInitialConcentration(self):
        """
        isSetInitialConcentration(Species self) -> bool


        Predicate returning 'True' if this Species object's
        'initialConcentration' attribute is set.

        Returns 'True' if the 'initialConcentration' attribute of this Species
        is set, 'False' otherwise.

        Note: The attribute 'initialConcentration' is only available in SBML
        Level 2 and 3.  It does not exist on Species in Level 1.

        """
        return _libsbml.Species_isSetInitialConcentration(self)


    def isSetSubstanceUnits(self):
        """
        isSetSubstanceUnits(Species self) -> bool


        Predicate returning 'True' if this Species object's 'substanceUnits'
        attribute is set.

        Returns 'True' if the 'substanceUnits' attribute of this Species is
        set, 'False' otherwise.

        """
        return _libsbml.Species_isSetSubstanceUnits(self)


    def isSetSpatialSizeUnits(self):
        """
        isSetSpatialSizeUnits(Species self) -> bool


        Predicate returning 'True' if this Species object's 'spatialSizeUnits'
        attribute is set.

        Returns 'True' if the 'spatialSizeUnits' attribute of this Species is
        set, 'False' otherwise.

        WARNING:

        In versions of SBML Level 2 before Version 3, the class Species
        included an attribute called 'spatialSizeUnits', which allowed
        explicitly setting the units of size for initial concentration.  This
        attribute was removed in SBML Level 2 Version 3.  LibSBML retains this
        attribute for compatibility with older definitions of Level 2, but its
        use is strongly discouraged because it is incompatible with levels and
        versions of SBML beyond Level 2 Version 2.

        """
        return _libsbml.Species_isSetSpatialSizeUnits(self)


    def isSetUnits(self):
        """
        isSetUnits(Species self) -> bool


        Predicate returning 'True' if this Species object's 'units' attribute
        is set.

        Returns 'True' if the 'units' attribute of this Species is set,
        'False' otherwise.

        """
        return _libsbml.Species_isSetUnits(self)


    def isSetCharge(self):
        """
        isSetCharge(Species self) -> bool


        Predicate returning 'True' if this Species object's 'charge' attribute
        is set.

        Returns 'True' if the 'charge' attribute of this Species is set,
        'False' otherwise.

        Note: Beginning in SBML Level 2 Version 2, the 'charge' attribute on
        Species is deprecated and in SBML Level 3 it does not exist at all.
        Its use strongly discouraged.  Its presence is considered a misfeature
        in earlier definitions of SBML because its implications for the
        mathematics of a model were never defined, and in any case, no known
        modeling system ever used it.  Instead, models take account of charge
        values directly in their definitions of species by (for example)
        having separate species identities for the charged and uncharged
        versions of the same species.  This allows the condition to affect
        model mathematics directly.  LibSBML retains this method for easier
        compatibility with SBML Level 1.

        """
        return _libsbml.Species_isSetCharge(self)


    def isSetConversionFactor(self):
        """
        isSetConversionFactor(Species self) -> bool


        Predicate returning 'True' if this Species object's 'conversionFactor'
        attribute is set.

        Returns 'True' if the 'conversionFactor' attribute of this Species is
        set, 'False' otherwise.

        Note: The 'conversionFactor' attribute was introduced in SBML Level 3.
        It does not exist on Species in SBML Levels 1 and 2.

        """
        return _libsbml.Species_isSetConversionFactor(self)


    def isSetBoundaryCondition(self):
        """
        isSetBoundaryCondition(Species self) -> bool


        Predicate returning 'True' if this Species object's
        'boundaryCondition' attribute is set.

        Returns 'True' if the 'boundaryCondition' attribute of this Species is
        set, 'False' otherwise.

        """
        return _libsbml.Species_isSetBoundaryCondition(self)


    def isSetHasOnlySubstanceUnits(self):
        """
        isSetHasOnlySubstanceUnits(Species self) -> bool


        Predicate returning 'True' if this Species object's
        'hasOnlySubstanceUnits' attribute is set.

        Returns 'True' if the 'hasOnlySubstanceUnits' attribute of this
        Species is set, 'False' otherwise.

        Note: The 'hasOnlySubstanceUnits' attribute does not exist in SBML
        Level 1.

        """
        return _libsbml.Species_isSetHasOnlySubstanceUnits(self)


    def isSetConstant(self):
        """
        isSetConstant(Species self) -> bool


        Predicate returning 'True' if this Species object's 'constant'
        attribute is set.

        Returns 'True' if the 'constant' attribute of this Species is set,
        'False' otherwise.

        Note: The attribute 'constant' is only available in SBML Levels 2 and
        3.  It does not exist on Species in Level 1.

        """
        return _libsbml.Species_isSetConstant(self)


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


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

        The string 'sid' is copied.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Parameter 'sid' is the string to use as the identifier of this object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.Species_setId(self, sid)


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


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

        The string in 'name' is copied.

        Parameter 'name' is the new name for the SBML object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Species_setName(self, name)


    def setSpeciesType(self, sid):
        """
        setSpeciesType(Species self, string sid) -> int


        Sets the 'speciesType' attribute of this Species object.

        Parameter 'sid' is the identifier of a SpeciesType object defined
        elsewhere in this Model.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        Note: The 'speciesType' attribute is only available in SBML Level 2
        Versions 2-4.

        """
        return _libsbml.Species_setSpeciesType(self, sid)


    def setCompartment(self, sid):
        """
        setCompartment(Species self, string sid) -> int


        Sets the 'compartment' attribute of this Species object.

        Parameter 'sid' is the identifier of a Compartment object defined
        elsewhere in this Model.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Species_setCompartment(self, sid)


    def setInitialAmount(self, value):
        """
        setInitialAmount(Species self, double value) -> int


        Sets the 'initialAmount' attribute of this Species and marks the field
        as set.

        This method also unsets the 'initialConcentration' attribute.

        Parameter 'value' is the value to which the 'initialAmount' attribute
        should be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.Species_setInitialAmount(self, value)


    def setInitialConcentration(self, value):
        """
        setInitialConcentration(Species self, double value) -> int


        Sets the 'initialConcentration' attribute of this Species and marks
        the field as set.

        This method also unsets the 'initialAmount' attribute.

        Parameter 'value' is the value to which the 'initialConcentration'
        attribute should be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        Note: The attribute 'initialConcentration' is only available in SBML
        Level 2 and 3.  It does not exist on Species in Level 1.

        """
        return _libsbml.Species_setInitialConcentration(self, value)


    def setSubstanceUnits(self, sid):
        """
        setSubstanceUnits(Species self, string sid) -> int


        Sets the 'substanceUnits' attribute of this Species object.

        Parameter 'sid' is the identifier of the unit to use.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Species_setSubstanceUnits(self, sid)


    def setSpatialSizeUnits(self, sid):
        """
        setSpatialSizeUnits(Species self, string sid) -> int


        (SBML Level 2 Versions 1-2) Sets the 'spatialSizeUnits' attribute of
        this Species object.

        Parameter 'sid' is the identifier of the unit to use.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        WARNING:

        In versions of SBML Level 2 before Version 3, the class Species
        included an attribute called 'spatialSizeUnits', which allowed
        explicitly setting the units of size for initial concentration.  This
        attribute was removed in SBML Level 2 Version 3.  LibSBML retains this
        attribute for compatibility with older definitions of Level 2, but its
        use is strongly discouraged because it is incompatible with levels and
        versions of SBML beyond Level 2 Version 2.

        """
        return _libsbml.Species_setSpatialSizeUnits(self, sid)


    def setUnits(self, sname):
        """
        setUnits(Species self, string sname) -> int


        (SBML Level 1 only) Sets the units of this Species object.

        Parameter 'sname' is the identifier of the unit to use.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Species_setUnits(self, sname)


    def setHasOnlySubstanceUnits(self, value):
        """
        setHasOnlySubstanceUnits(Species self, bool value) -> int


        Sets the 'hasOnlySubstanceUnits' attribute of this Species object.

        Parameter 'value' is boolean value for the 'hasOnlySubstanceUnits'
        attribute.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        Note: The 'hasOnlySubstanceUnits' attribute does not exist in SBML
        Level 1.

        """
        return _libsbml.Species_setHasOnlySubstanceUnits(self, value)


    def setBoundaryCondition(self, value):
        """
        setBoundaryCondition(Species self, bool value) -> int


        Sets the 'boundaryCondition' attribute of this Species object.

        Parameter 'value' is boolean value for the 'boundaryCondition'
        attribute.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.Species_setBoundaryCondition(self, value)


    def setCharge(self, value):
        """
        setCharge(Species self, int value) -> int


        Sets the 'charge' attribute of this Species object.

        Parameter 'value' is an integer to which to set the 'charge' to.

        Note: Beginning in SBML Level 2 Version 2, the 'charge' attribute on
        Species is deprecated and in SBML Level 3 it does not exist at all.
        Its use strongly discouraged.  Its presence is considered a misfeature
        in earlier definitions of SBML because its implications for the
        mathematics of a model were never defined, and in any case, no known
        modeling system ever used it.  Instead, models take account of charge
        values directly in their definitions of species by (for example)
        having separate species identities for the charged and uncharged
        versions of the same species.  This allows the condition to affect
        model mathematics directly.  LibSBML retains this method for easier
        compatibility with SBML Level 1.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        """
        return _libsbml.Species_setCharge(self, value)


    def setConstant(self, value):
        """
        setConstant(Species self, bool value) -> int


        Sets the 'constant' attribute of this Species object.

        Parameter 'value' is a boolean value for the 'constant' attribute.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        Note: The attribute 'constant' is only available in SBML Levels 2 and
        3.  It does not exist on Species in Level 1.

        """
        return _libsbml.Species_setConstant(self, value)


    def setConversionFactor(self, sid):
        """
        setConversionFactor(Species self, string sid) -> int


        Sets the value of the 'conversionFactor' attribute of this Species
        object.

        The string in 'sid' is copied.

        Parameter 'sid' is the new conversionFactor for the Species.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        Note: The 'conversionFactor' attribute was introduced in SBML Level 3.
        It does not exist on Species in SBML Levels 1 and 2.

        """
        return _libsbml.Species_setConversionFactor(self, sid)


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


        Unsets the value of the 'name' attribute of this Species object.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getName(), setName(), isSetName().

        """
        return _libsbml.Species_unsetName(self)


    def unsetConstant(self):
        """
        unsetConstant(Species self) -> int


        Unsets the value of the 'constant' attribute of this Species object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also isSetConstant(), setConstant(), getConstant().

        """
        return _libsbml.Species_unsetConstant(self)


    def unsetSpeciesType(self):
        """
        unsetSpeciesType(Species self) -> int


        Unsets the 'speciesType' attribute value of this Species object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        Note: The attribute 'speciesType' is only available in SBML Level 2
        Versions 2-4.

        """
        return _libsbml.Species_unsetSpeciesType(self)


    def unsetInitialAmount(self):
        """
        unsetInitialAmount(Species self) -> int


        Unsets the 'initialAmount' attribute value of this Species object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Species_unsetInitialAmount(self)


    def unsetInitialConcentration(self):
        """
        unsetInitialConcentration(Species self) -> int


        Unsets the 'initialConcentration' attribute value of this Species
        object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        Note: The attribute 'initialConcentration' is only available in SBML
        Level 2 and 3.  It does not exist on Species in Level 1.

        """
        return _libsbml.Species_unsetInitialConcentration(self)


    def unsetSubstanceUnits(self):
        """
        unsetSubstanceUnits(Species self) -> int


        Unsets the 'substanceUnits' attribute value of this Species object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Species_unsetSubstanceUnits(self)


    def unsetSpatialSizeUnits(self):
        """
        unsetSpatialSizeUnits(Species self) -> int


        Unsets the 'spatialSizeUnits' attribute value of this Species object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        WARNING:

        In versions of SBML Level 2 before Version 3, the class Species
        included an attribute called 'spatialSizeUnits', which allowed
        explicitly setting the units of size for initial concentration.  This
        attribute was removed in SBML Level 2 Version 3.  LibSBML retains this
        attribute for compatibility with older definitions of Level 2, but its
        use is strongly discouraged because it is incompatible with levels and
        versions of SBML beyond Level 2 Version 2.

        """
        return _libsbml.Species_unsetSpatialSizeUnits(self)


    def unsetUnits(self):
        """
        unsetUnits(Species self) -> int


        Unsets the 'units' attribute value of this Species object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Species_unsetUnits(self)


    def unsetCharge(self):
        """
        unsetCharge(Species self) -> int


        Unsets the 'charge' attribute value of this Species object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        * LIBSBML_OPERATION_FAILED

        Note: Beginning in SBML Level 2 Version 2, the 'charge' attribute on
        Species is deprecated and in SBML Level 3 it does not exist at all.
        Its use strongly discouraged.  Its presence is considered a misfeature
        in earlier definitions of SBML because its implications for the
        mathematics of a model were never defined, and in any case, no known
        modeling system ever used it.  Instead, models take account of charge
        values directly in their definitions of species by (for example)
        having separate species identities for the charged and uncharged
        versions of the same species.  This allows the condition to affect
        model mathematics directly.  LibSBML retains this method for easier
        compatibility with SBML Level 1.

        """
        return _libsbml.Species_unsetCharge(self)


    def unsetConversionFactor(self):
        """
        unsetConversionFactor(Species self) -> int


        Unsets the 'conversionFactor' attribute value of this Species object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        * LIBSBML_OPERATION_FAILED

        Note: The 'conversionFactor' attribute was introduced in SBML Level 3.
        It does not exist on Species in SBML Levels 1 and 2.

        """
        return _libsbml.Species_unsetConversionFactor(self)


    def unsetCompartment(self):
        """
        unsetCompartment(Species self) -> int


        Unsets the 'compartment' attribute value of this Species object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Species_unsetCompartment(self)


    def unsetBoundaryCondition(self):
        """
        unsetBoundaryCondition(Species self) -> int


        Unsets the 'boundaryCondition' attribute value of this Species object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Species_unsetBoundaryCondition(self)


    def unsetHasOnlySubstanceUnits(self):
        """
        unsetHasOnlySubstanceUnits(Species self) -> int


        Unsets the 'hasOnlySubstanceUnits' attribute value of this Species
        object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Species_unsetHasOnlySubstanceUnits(self)


    def getDerivedUnitDefinition(self, *args):
        """
        getDerivedUnitDefinition(Species self) -> UnitDefinition
        getDerivedUnitDefinition(Species self) -> UnitDefinition


        Constructs and returns a UnitDefinition that corresponds to the units
        of this Species' amount or concentration.

        Species in SBML have an attribute ('substanceUnits') for declaring the
        units of measurement intended for the species' amount or concentration
        (depending on which one applies).  In the absence of a value given for
        'substanceUnits', the units are taken from the enclosing Model's
        definition of ''substance'' or ''substance'/(size' of the compartment)
        in which the species is located, or finally, if these are not
        redefined by the Model, the relevant SBML default units for those
        quantities.  Following that procedure, the method
        getDerivedUnitDefinition() returns a UnitDefinition based on the
        interpreted units of this species's amount or concentration.

        Note that the functionality that facilitates unit analysis depends  on
        the model as a whole.  Thus, in cases where the object has not  been
        added to a model or the model itself is incomplete, unit analysis is
        not possible and this method will return 'None.'

        Note also that unit declarations for Species are in terms of the
        identifier of a unit, but this method returns a UnitDefinition object,
        not a unit identifier.  It does this by constructing an appropriate
        UnitDefinition.  Callers may find this particularly useful when used
        in conjunction with the helper methods on UnitDefinition for comparing
        different UnitDefinition objects.

        In SBML Level 2 specifications prior to Version 3, Species includes an
        additional attribute named 'spatialSizeUnits', which allows explicitly
        setting the units of size for initial concentration. The
        getDerivedUnitDefinition() takes this into account for models
        expressed in SBML Level 2 Versions 1 and 2.

        Returns a UnitDefinition that expresses the units of this  Species, or
        'None' if one cannot be constructed.

        See also getSubstanceUnits().

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


    def getTypeCode(self):
        """
        getTypeCode(Species self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_SPECIES (default).

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.Species_getTypeCode(self)


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


        Returns the XML element name of this object, which for Species, is
        always ''species'.'

        Returns the name of this element, i.e., ''species'.'

        """
        return _libsbml.Species_getElementName(self)


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


        Predicate returning 'True' if all the required attributes for this
        Species object have been set.

        The required attributes for a Species object are:

        * 'id' (or 'name' in SBML Level 1)

        * 'compartment'

        * 'initialAmount' (required in SBML Level 1 only; optional
        otherwise)

        * 'hasOnlySubstanceUnits' (required in SBML Level 3; optional in
        SBML Level 2)

        * 'boundaryCondition' (required in SBML Level 3; optional in Levels
        1 and 2)

        * 'constant' (required in SBML Level 3; optional in SBML Level 2)

        Returns 'True' if the required attributes have been set, 'False'
        otherwise.

        """
        return _libsbml.Species_hasRequiredAttributes(self)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(Species self, string oldid, string newid)


        Replaces all uses of a given 'SIdRef' type attribute value with
        another value.

        In SBML, object identifiers are of a data type called SId. In SBML
        Level 3, an explicit data type called SIdRef was introduced for
        attribute values that refer to SId values; in previous Levels of SBML,
        this data type did not exist and attributes were simply described to
        as 'referring to an identifier', but the effective data type was the
        same as SIdRef in Level 3.  These and other methods of libSBML refer
        to the type SIdRef for all Levels of SBML, even if the corresponding
        SBML specification did not explicitly name the data type.

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas in MathML content, comparing the referenced
        identifiers to the value of 'oldid'.  If any matches are found, the
        matching values are replaced with 'newid'.  The method does not
        descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.Species_renameSIdRefs(self, oldid, newid)


    def renameUnitSIdRefs(self, oldid, newid):
        """
        renameUnitSIdRefs(Species self, string oldid, string newid)


        Replaces all uses of a given 'UnitSIdRef' type attribute value with
        another value.

        In SBML, unit definitions have identifiers of type UnitSId.  In SBML
        Level 3, an explicit data type called UnitSIdRef was introduced for
        attribute values that refer to UnitSId values; in previous Levels of
        SBML, this data type did not exist and attributes were simply
        described to as 'referring to a unit identifier', but the effective
        data type was the same as UnitSIdRef in Level 3.  These and other
        methods of libSBML refer to the type UnitSIdRef for all Levels of
        SBML, even if the corresponding SBML specification did not explicitly
        name the data type.

        This method works by looking at all unit identifier attribute values
        (including, if appropriate, inside mathematical formulas), comparing
        the referenced unit identifiers to the value of 'oldid'.  If any
        matches are found, the matching values are replaced with 'newid'.  The
        method does not descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.Species_renameUnitSIdRefs(self, oldid, newid)

Species_swigregister = _libsbml.Species_swigregister
Species_swigregister(Species)

class ListOfSpecies(ListOf):
    """

    A list of Species objects.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfSpecies, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfSpecies, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ListOfSpecies self, unsigned int level, unsigned int version) -> ListOfSpecies
        __init__(ListOfSpecies self, SBMLNamespaces sbmlns) -> ListOfSpecies


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfSpecies(SBMLNamespaces sbmlns)

        Creates a new ListOfSpecies object.

        The object is constructed such that it is valid for the SBML Level and
        Version combination determined by the SBMLNamespaces object in
        'sbmlns'.

        Parameter 'sbmlns' is an SBMLNamespaces object that is used to
        determine the characteristics of the ListOfSpecies object to be
        created.

        Throws SBMLConstructorException: Thrown if the given 'sbmlns' is
        inconsistent or incompatible with this object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfSpecies(long level, long version)

        Creates a new ListOfSpecies object.

        The object is constructed such that it is valid for the given SBML
        Level and Version combination.

        Parameter 'level' is the SBML Level.

        Parameter 'version' is the Version within the SBML Level.

        Throws SBMLConstructorException: Thrown if the given 'level' and
        'version' combination are invalid or if this object is incompatible
        with the given level and version.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        """
        this = _libsbml.new_ListOfSpecies(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ListOfSpecies self) -> ListOfSpecies


        Creates and returns a deep copy of this ListOfSpecies object.

        Returns the (deep) copy of this ListOfSpecies object.

        """
        return _libsbml.ListOfSpecies_clone(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfSpecies self) -> int


        Returns the libSBML type code for the objects contained in this ListOf
        (i.e., Species objects, if the list is non-empty).

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for objects contained in this list:
        SBML_SPECIES (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfSpecies_getItemTypeCode(self)


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


        Returns the XML element name of this object.

        For ListOfSpeciess, the XML element name is ''listOfSpeciess'.'

        Returns the name of this element, i.e., ''listOfSpeciess'.'

        """
        return _libsbml.ListOfSpecies_getElementName(self)


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a Species from the ListOfSpecies.

        Parameter 'n' is the index number of the Species to get.

        Returns the nth Species in this ListOfSpecies. If the index 'n' is
        invalid, 'None' is returned.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a Species from the ListOfSpecies based on its identifier.

        Parameter 'sid' is a string representing the identifier  of the
        Species to get.

        Returns Species in this ListOfSpecies with the given 'sid' or 'None'
        if no such Species exists.

        See also get(), size().

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


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth item from this ListOfSpeciess items and returns a
        pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the item to remove.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes item in this ListOfSpeciess 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 'sid', then
        'None' is returned.

        Parameter 'sid' is the identifier of the item to remove.

        Returns the item removed.  As mentioned above, the caller owns the
        returned item.

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

    __swig_destroy__ = _libsbml.delete_ListOfSpecies
    __del__ = lambda self: None
ListOfSpecies_swigregister = _libsbml.ListOfSpecies_swigregister
ListOfSpecies_swigregister(ListOfSpecies)

class Parameter(SBase):
    """

    An SBML parameter: a named symbol with a value.

    A Parameter is used in SBML to define a symbol associated with a
    value; this symbol can then be used in mathematical formulas in a
    model.  By default, parameters have constant value for the duration of
    a simulation, and for this reason are called parameters instead of
    variables in SBML, although it is crucial to understand that SBML
    parameters represent both concepts.  Whether a given SBML parameter is
    intended to be constant or variable is indicated by the value of its
    'constant' attribute.

    SBML's Parameter has a required attribute, 'id', that gives the
    parameter a unique identifier by which other parts of an SBML model
    definition can refer to it.  A parameter can also have an optional
    'name' attribute of type 'string.'  Identifiers and names must be used
    according to the guidelines described in the SBML specifications.

    The optional attribute 'value' determines the value (of type 'float)'
    assigned to the parameter.  A missing value for 'value' implies that
    the value either is unknown, or to be obtained from an external
    source, or determined by an initial assignment.  The unit of
    measurement associated with the value of the parameter can be
    specified using the optional attribute 'units'.  Here we only mention
    briefly some notable points about the possible unit choices, but
    readers are urged to consult the SBML specification documents for more
    information:

    * In SBML Level 3, there are no constraints on the units that can be
    assigned to parameters in a model; there are also no units to inherit
    from the enclosing Model object (unlike the case for, e.g., Species
    and Compartment).

    * In SBML Level 2, the value assigned to the parameter's 'units'
    attribute must be chosen from one of the following possibilities: one
    of the base unit identifiers defined in SBML; one of the built-in unit
    identifiers ''substance',' ''time',' ''volume',' ''area'' or
    ''length';' or the identifier of a new unit defined in the list of
    unit definitions in the enclosing Model structure.  There are no
    constraints on the units that can be chosen from these sets.  There
    are no default units for parameters. The Parameter structure has
    another boolean attribute named 'constant' that is used to indicate
    whether the parameter's value can vary during a simulation.  (In SBML
    Level 3, the attribute is mandatory and must be given a value; in SBML
    Levels below Level 3, the attribute is optional.)  A value of 'True'
    indicates the parameter's value cannot be changed by any construct
    except InitialAssignment.  Conversely, if the value of 'constant' is
    'False,' other constructs in SBML, such as rules and events, can
    change the value of the parameter.

    SBML Level 3 uses a separate object class, LocalParameter, for
    parameters that are local to a Reaction's KineticLaw.  In Levels prior
    to SBML Level 3, the Parameter class is used both for definitions of
    global parameters, as well as reaction-local parameters stored in a
    list within KineticLaw objects.  Parameter objects that are local to a
    reaction (that is, those defined within the KineticLaw structure of a
    Reaction) cannot be changed by rules and therefore are implicitly
    always constant; consequently, in SBML Level 2, parameter definitions
    within Reaction structures should not have their 'constant' attribute
    set to 'False.'

    What if a global parameter has its 'constant' attribute set to
    'False,' but the model does not contain any rules, events or other
    constructs that ever change its value over time?  Although the model
    may be suspect, this situation is not strictly an error.  A value of
    'False' for 'constant' only indicates that a parameter can change
    value, not that it must.

    As with all other major SBML components, Parameter is derived from
    SBase, and the methods defined on SBase are available on Parameter.

    Note: The use of the term parameter in SBML sometimes leads to
    confusion among readers who have a particular notion of what something
    called 'parameter' should be.  It has been the source of heated
    debate, but despite this, no one has yet found an adequate replacement
    term that does not have different connotations to different people and
    hence leads to confusion among some subset of users.  Perhaps it would
    have been better to have two constructs, one called constants and the
    other called variables.  The current approach in SBML is simply more
    parsimonious, using a single Parameter construct with the boolean flag
    'constant' indicating which flavor it is.  In any case, readers are
    implored to look past their particular definition of a parameter and
    simply view SBML's Parameter as a single mechanism for defining both
    constants and (additional) variables in a model.  (We write additional
    because the species in a model are usually considered to be the
    central variables.)  After all, software tools are not required to
    expose to users the actual names of particular SBML constructs, and
    thus tools can present to their users whatever terms their designers
    feel best matches their target audience.

    In SBML Level 3 Version 2, many restrictions were lifted  requiring
    only Boolean values in Boolean contexts, and numeric values in numeric
    contexts.  This means that a Parameter may now be used as a Boolean,
    despite canonically having a numeric value. To be consistent, one
    should always assign it a value of 'True' or 'False,' and use it in
    Boolean contexts exclusively.  It would be appropriate to give it an
    SBO value of 602 ('Logical parameter') if one chooses to do this.

    See also ListOfParameters.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Parameter, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Parameter, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_Parameter
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(Parameter self, unsigned int level, unsigned int version) -> Parameter
        __init__(Parameter self, SBMLNamespaces sbmlns) -> Parameter
        __init__(Parameter self, Parameter orig) -> Parameter


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            Parameter(SBMLNamespaces sbmlns)

        Creates a new Parameter using the given SBMLNamespaces object
        'sbmlns'.

        The SBMLNamespaces object encapsulates SBML Level/Version/namespaces
        information.  It is used to communicate the SBML Level, Version, and
        (in Level 3) packages used in addition to SBML Level 3 Core.  A common
        approach to using libSBML's SBMLNamespaces facilities is to create an
        SBMLNamespaces object somewhere in a program once, then hand that
        object as needed to object constructors that accept SBMLNamespaces as
        arguments.

        It is worth emphasizing that although this constructor does not take
        an identifier argument, in SBML Level 2 and beyond, the 'id'
        (identifier) attribute of a Parameter is required to have a value.
        Thus, callers are cautioned to assign a value after calling this
        constructor if no identifier is provided as an argument.  Setting the
        identifier can be accomplished using the method setId().

        Parameter 'sbmlns' is an SBMLNamespaces object.

        Throws SBMLConstructorException: Thrown if the given 'sbmlns' is
        inconsistent or incompatible with this object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            Parameter(long level, long version)

        Creates a new Parameter using the given SBML 'level' and 'version'
        values.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        Parameter.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this Parameter.

        Throws SBMLConstructorException: Thrown if the given 'level' and
        'version' combination are invalid or if this object is incompatible
        with the given level and version.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            Parameter(Parameter orig)

        Copy constructor; creates a copy of a Parameter.

        Parameter 'orig' is the Parameter instance to copy.

        """
        this = _libsbml.new_Parameter(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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


        Creates and returns a deep copy of this Parameter object.

        Returns the (deep) copy of this Parameter object.

        """
        return _libsbml.Parameter_clone(self)


    def initDefaults(self):
        """
        initDefaults(Parameter self)


        Initializes the fields of this Parameter object to 'typical' defaults
        values.

        The SBML Parameter component has slightly different aspects and
        default attribute values in different SBML Levels and Versions.  Many
        SBML object classes defined by libSBML have an initDefaults() method
        to set the values to certain common defaults, based mostly on what
        they are in SBML Level 2.  In the case of Parameter, this method only
        sets the value of the 'constant' attribute to 'True.'

        See also getConstant(), isSetConstant(), setConstant().

        """
        return _libsbml.Parameter_initDefaults(self)


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


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

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is now recommended to use the
        getIdAttribute() function instead.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns the id of this Parameter.

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.Parameter_getId(self)


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


        Returns the value of the 'name' attribute of this Parameter object.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns the name of this SBML object, or the empty string if not set
        or unsettable.

        See also getIdAttribute(), isSetName(), setName(), unsetName().

        """
        return _libsbml.Parameter_getName(self)


    def getValue(self):
        """
        getValue(Parameter self) -> double


        Gets the numerical value of this Parameter.

        Returns the value of the 'value' attribute of this Parameter, as a
        number of type 'float.'

        Note: It is crucial that callers not blindly call Parameter.getValue()
        without first using Parameter.isSetValue() to determine whether a
        value has ever been set.  Otherwise, the value return by
        Parameter.getValue() may not actually represent a value assigned to
        the parameter.  The reason is simply that the data type 'float' in a
        program always has some value.  A separate test is needed to determine
        whether the value is a true model value, or uninitialized data in a
        computer's memory location.

        See also isSetValue(), setValue(), getUnits().

        """
        return _libsbml.Parameter_getValue(self)


    def getUnits(self):
        """
        getUnits(Parameter self) -> string


        Gets the units defined for this Parameter.

        The value of an SBML parameter's 'units' attribute establishes the
        unit of measurement associated with the parameter's value.

        Returns the value of the 'units' attribute of this Parameter, as a
        string.  An empty string indicates that no units have been assigned.

        Note: There is an important distinction to be made between no units
        assigned, and assuming a value without units has any specific unit
        such as dimensionless.  In SBML, default units are never attributed to
        numbers, and numbers without units are not automatically assumed to
        have the unit dimensionless.  Please consult the relevant SBML
        specification document for a more in-depth explanation of this topic
        and the SBML unit system.

        See also isSetUnits(), setUnits(), getValue().

        """
        return _libsbml.Parameter_getUnits(self)


    def getConstant(self):
        """
        getConstant(Parameter self) -> bool


        Gets the value of the 'constant' attribute of this Parameter instance.

        Returns 'True' if this Parameter is declared as being constant,
        'False' otherwise.

        Note: Readers who view the documentation for LocalParameter may be
        confused about the presence of this method.  LibSBML derives
        LocalParameter from Parameter; however, this does not precisely match
        the object hierarchy defined by SBML Level 3, where LocalParameter is
        derived directly from SBase and not Parameter.  We believe this
        arrangement makes it easier for libSBML users to program applications
        that work with both SBML Level 2 and SBML Level 3, but programmers
        should also keep in mind this difference exists.  A side-effect of
        libSBML's scheme is that certain methods on LocalParameter that are
        inherited from Parameter do not actually have relevance to
        LocalParameter objects.  An example of this is the methods pertaining
        to Parameter's attribute 'constant' (i.e., isSetConstant(),
        setConstant(), and getConstant()).

        See also isSetConstant(), setConstant().

        """
        return _libsbml.Parameter_getConstant(self)


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


        Predicate returning 'True' if this Parameter's 'id' attribute is set.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns 'True' if the 'id' attribute of this SBML object is set,
        'False' otherwise.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is recommended that callers use
        isSetIdAttribute() instead.

        See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(),
        isSetIdAttribute().

        """
        return _libsbml.Parameter_isSetId(self)


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


        Predicate returning 'True' if this Parameter's 'name' attribute is
        set.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns 'True' if the 'name' attribute of this SBML object is set,
        'False' otherwise.

        See also getName(), setName(), unsetName().

        """
        return _libsbml.Parameter_isSetName(self)


    def isSetValue(self):
        """
        isSetValue(Parameter self) -> bool


        Predicate returning 'True' if the 'value' attribute of this Parameter
        is set.

        In SBML definitions after SBML Level 1 Version 1, parameter values are
        optional and have no defaults.  If a model read from a file does not
        contain a setting for the 'value' attribute of a parameter, its value
        is considered unset; it does not default to any particular value.
        Similarly, when a Parameter object is created in libSBML, it has no
        value until given a value.  The Parameter.isSetValue() method allows
        calling applications to determine whether a given parameter's value
        has ever been set.

        In SBML Level 1 Version 1, parameters are required to have values and
        therefore, the value of a Parameter should always be set.  In Level 1
        Version 2 and beyond, the value is optional and as such, the 'value'
        attribute may or may not be set.

        Returns 'True' if the value of this Parameter is set, 'False'
        otherwise.

        See also getValue(), setValue().

        """
        return _libsbml.Parameter_isSetValue(self)


    def isSetUnits(self):
        """
        isSetUnits(Parameter self) -> bool


        Predicate returning 'True' if the 'units' attribute of this Parameter
        is set.

        Returns 'True' if the 'units' attribute of this Parameter is set,
        'False' otherwise.

        Note: There is an important distinction to be made between no units
        assigned, and assuming a value without units has any specific unit
        such as dimensionless.  In SBML, default units are never attributed to
        numbers, and numbers without units are not automatically assumed to
        have the unit dimensionless.  Please consult the relevant SBML
        specification document for a more in-depth explanation of this topic
        and the SBML unit system.

        """
        return _libsbml.Parameter_isSetUnits(self)


    def isSetConstant(self):
        """
        isSetConstant(Parameter self) -> bool


        Predicate returning 'True' if the 'constant' attribute of this
        Parameter is set.

        Returns 'True' if the 'constant' attribute of this Parameter is set,
        'False' otherwise.

        Note: Readers who view the documentation for LocalParameter may be
        confused about the presence of this method.  LibSBML derives
        LocalParameter from Parameter; however, this does not precisely match
        the object hierarchy defined by SBML Level 3, where LocalParameter is
        derived directly from SBase and not Parameter.  We believe this
        arrangement makes it easier for libSBML users to program applications
        that work with both SBML Level 2 and SBML Level 3, but programmers
        should also keep in mind this difference exists.  A side-effect of
        libSBML's scheme is that certain methods on LocalParameter that are
        inherited from Parameter do not actually have relevance to
        LocalParameter objects.  An example of this is the methods pertaining
        to Parameter's attribute 'constant' (i.e., isSetConstant(),
        setConstant(), and getConstant()).

        See also getConstant(), setConstant().

        """
        return _libsbml.Parameter_isSetConstant(self)


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


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

        The string 'sid' is copied.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Parameter 'sid' is the string to use as the identifier of this object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.Parameter_setId(self, sid)


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


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

        The string in 'name' is copied.

        Parameter 'name' is the new name for the Parameter.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Parameter_setName(self, name)


    def setValue(self, value):
        """
        setValue(Parameter self, double value) -> int


        Sets the 'value' attribute of this Parameter to the given 'float'
        value and marks the attribute as set.

        Parameter 'value' is a 'float,' the value to assign.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.Parameter_setValue(self, value)


    def setUnits(self, units):
        """
        setUnits(Parameter self, string units) -> int


        Sets the 'units' attribute of this Parameter to a copy of the given
        units identifier 'units'.

        Parameter 'units' is a string, the identifier of the units to assign
        to this Parameter instance.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Parameter_setUnits(self, units)


    def setConstant(self, flag):
        """
        setConstant(Parameter self, bool flag) -> int


        Sets the 'constant' attribute of this Parameter to the given boolean
        'flag'.

        Parameter 'flag' is a boolean, the value for the 'constant' attribute
        of this Parameter instance.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        Note: Readers who view the documentation for LocalParameter may be
        confused about the presence of this method.  LibSBML derives
        LocalParameter from Parameter; however, this does not precisely match
        the object hierarchy defined by SBML Level 3, where LocalParameter is
        derived directly from SBase and not Parameter.  We believe this
        arrangement makes it easier for libSBML users to program applications
        that work with both SBML Level 2 and SBML Level 3, but programmers
        should also keep in mind this difference exists.  A side-effect of
        libSBML's scheme is that certain methods on LocalParameter that are
        inherited from Parameter do not actually have relevance to
        LocalParameter objects.  An example of this is the methods pertaining
        to Parameter's attribute 'constant' (i.e., isSetConstant(),
        setConstant(), and getConstant()).

        See also getConstant(), isSetConstant().

        """
        return _libsbml.Parameter_setConstant(self, flag)


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


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

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getName(), setName(), isSetName().

        """
        return _libsbml.Parameter_unsetName(self)


    def unsetConstant(self):
        """
        unsetConstant(Parameter self) -> int


        Unsets the value of the 'constant' attribute of this Parameter object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also isSetConstant(), setConstant(), getConstant().

        """
        return _libsbml.Parameter_unsetConstant(self)


    def unsetValue(self):
        """
        unsetValue(Parameter self) -> int


        Unsets the 'value' attribute of this Parameter instance.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        In SBML Level 1 Version 1, parameters are required to have values and
        therefore, the value of a Parameter should always be set.  In SBML
        Level 1 Version 2 and beyond, the value is optional and as such, the
        'value' attribute may or may not be set.

        """
        return _libsbml.Parameter_unsetValue(self)


    def unsetUnits(self):
        """
        unsetUnits(Parameter self) -> int


        Unsets the 'units' attribute of this Parameter instance.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Parameter_unsetUnits(self)


    def getDerivedUnitDefinition(self, *args):
        """
        getDerivedUnitDefinition(Parameter self) -> UnitDefinition
        getDerivedUnitDefinition(Parameter self) -> UnitDefinition


        Constructs and returns a UnitDefinition that corresponds to the units
        of this Parameter's value.

        Parameters in SBML have an attribute ('units') for declaring the units
        of measurement intended for the parameter's value.  No defaults are
        defined by SBML in the absence of a definition for 'units'.  This
        method returns a UnitDefinition object based on the units declared for
        this Parameter using its 'units' attribute, or it returns 'None' if no
        units have been declared.

        Note that unit declarations for Parameter objects are specified in
        terms of the identifier of a unit (e.g., using setUnits()), but this
        method returns a UnitDefinition object, not a unit identifier.  It
        does this by constructing an appropriate UnitDefinition.For SBML Level
        2 models, it will do this even when the value of the 'units' attribute
        is one of the special SBML Level 2 unit identifiers ''substance','
        ''volume',' ''area',' ''length'' or ''time'.'  Callers may find this
        useful in conjunction with the helper methods provided by the
        UnitDefinition class for comparing different UnitDefinition objects.

        Returns a UnitDefinition that expresses the units of this  Parameter,
        or 'None' if one cannot be constructed.

        Note: The libSBML system for unit analysis depends on the model as a
        whole.  In cases where the Parameter object has not yet been added to
        a model, or the model itself is incomplete, unit analysis is not
        possible, and consequently this method will return 'None.'

        See also isSetUnits().

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


    def getTypeCode(self):
        """
        getTypeCode(Parameter self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_PARAMETER (default).

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.Parameter_getTypeCode(self)


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


        Returns the XML element name of this object, which for Parameter, is
        always ''parameter'.'

        Returns the name of this element, i.e., ''parameter'.'

        """
        return _libsbml.Parameter_getElementName(self)


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


        Predicate returning 'True' if all the required attributes for this
        Parameter object have been set.

        The required attributes for a Parameter object are:

        * 'id' (or 'name' in SBML Level 1)

        * 'value' (required in Level 1, optional otherwise)

        Returns 'True' if the required attributes have been set, 'False'
        otherwise.

        """
        return _libsbml.Parameter_hasRequiredAttributes(self)


    def renameUnitSIdRefs(self, oldid, newid):
        """
        renameUnitSIdRefs(Parameter self, string oldid, string newid)


        Renames all the 'UnitSIdRef' attributes on this element.

        In SBML, unit definitions have identifiers of type UnitSId.  In SBML
        Level 3, an explicit data type called UnitSIdRef was introduced for
        attribute values that refer to UnitSId values; in previous Levels of
        SBML, this data type did not exist and attributes were simply
        described to as 'referring to a unit identifier', but the effective
        data type was the same as UnitSIdRef in Level 3.  These and other
        methods of libSBML refer to the type UnitSIdRef for all Levels of
        SBML, even if the corresponding SBML specification did not explicitly
        name the data type.

        This method works by looking at all unit identifier attribute values
        (including, if appropriate, inside mathematical formulas), comparing
        the unit identifiers to the value of 'oldid'.  If any matches are
        found, the matching identifiers are replaced with 'newid'.  The method
        does not descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.Parameter_renameUnitSIdRefs(self, oldid, newid)


    def setCalculatingUnits(self, calculatingUnits):
        """
        setCalculatingUnits(Parameter self, bool calculatingUnits)


        Internal implementation method.

        """
        return _libsbml.Parameter_setCalculatingUnits(self, calculatingUnits)

Parameter_swigregister = _libsbml.Parameter_swigregister
Parameter_swigregister(Parameter)

class ListOfParameters(ListOf):
    """

    A list of Parameter objects.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfParameters, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfParameters, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ListOfParameters self, unsigned int level, unsigned int version) -> ListOfParameters
        __init__(ListOfParameters self, SBMLNamespaces sbmlns) -> ListOfParameters


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfParameters(SBMLNamespaces sbmlns)

        Creates a new ListOfParameters object.

        The object is constructed such that it is valid for the SBML Level and
        Version combination determined by the SBMLNamespaces object in
        'sbmlns'.

        Parameter 'sbmlns' is an SBMLNamespaces object that is used to
        determine the characteristics of the ListOfParameters object to be
        created.

        Throws SBMLConstructorException: Thrown if the given 'sbmlns' is
        inconsistent or incompatible with this object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfParameters(long level, long version)

        Creates a new ListOfParameters object.

        The object is constructed such that it is valid for the given SBML
        Level and Version combination.

        Parameter 'level' is the SBML Level.

        Parameter 'version' is the Version within the SBML Level.

        Throws SBMLConstructorException: Thrown if the given 'level' and
        'version' combination are invalid or if this object is incompatible
        with the given level and version.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        """
        this = _libsbml.new_ListOfParameters(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ListOfParameters self) -> ListOfParameters


        Creates and returns a deep copy of this ListOfParameters object.

        Returns the (deep) copy of this ListOfParameters object.

        """
        return _libsbml.ListOfParameters_clone(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfParameters self) -> int


        Returns the libSBML type code for the objects contained in this ListOf
        (i.e., Parameter objects, if the list is non-empty).

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this objects contained in this list:
        SBML_PARAMETER (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfParameters_getItemTypeCode(self)


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


        Returns the XML element name of this object.

        For ListOfParameters, the XML element name is ''listOfParameters'.'

        Returns the name of this element, i.e., ''listOfParameters'.'

        """
        return _libsbml.ListOfParameters_getElementName(self)


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Returns the Parameter object located at position 'n' within this
        ListOfParameters instance.

        Parameter 'n' is the index number of the Parameter to get.

        Returns the nth Parameter in this ListOfParameters.  If the index 'n'
        is out of bounds for the length of the list, then 'None' is returned.

        See also size(), get().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Returns the first Parameter object matching the given identifier.

        Parameter 'sid' is a string representing the identifier of the
        Parameter to get.

        Returns the Parameter object found.  The caller owns the returned
        object and is responsible for deleting it.  If none of the items have
        an identifier matching 'sid', then 'None' is returned.

        See also get(), size().

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


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth item from this ListOfParameters, and returns a pointer
        to it.

        Parameter 'n' is the index of the item to remove.

        Returns the item removed.  The caller owns the returned object and is
        responsible for deleting it.  If the index number 'n' is out of bounds
        for the length of the list, then 'None' is returned.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes the first Parameter object in this ListOfParameters matching
        the given identifier, and returns a pointer to it.

        Parameter 'sid' is the identifier of the item to remove.

        Returns the item removed.  The caller owns the returned object and is
        responsible for deleting it.  If none of the items have an identifier
        matching 'sid', then 'None' is returned.

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

    __swig_destroy__ = _libsbml.delete_ListOfParameters
    __del__ = lambda self: None
ListOfParameters_swigregister = _libsbml.ListOfParameters_swigregister
ListOfParameters_swigregister(ListOfParameters)

class LocalParameter(Parameter):
    """

    A parameter inside an SBML reaction definition.

    LocalParameter has been introduced in SBML Level 3 to serve as the
    object class for parameter definitions that are intended to be local
    to a Reaction.  Objects of class LocalParameter never appear at the
    Model level; they are always contained within ListOfLocalParameters
    lists which are in turn contained within KineticLaw objects.

    Like its global Parameter counterpart, the LocalParameter object class
    is used to define a symbol associated with a value; this symbol can
    then be used in a model's mathematical formulas (and specifically, for
    LocalParameter, reaction rate formulas).  Unlike Parameter, the
    LocalParameter class does not have a 'constant' attribute: local
    parameters within reactions are always constant.

    LocalParameter has one required attribute, 'id', to give the parameter
    a unique identifier by which other parts of an SBML model definition
    can refer to it.  A parameter can also have an optional 'name'
    attribute of type 'string.'  Identifiers and names must be used
    according to the guidelines described in the SBML specifications.

    The optional attribute 'value' determines the value (of type 'float)'
    assigned to the parameter.  A missing value for 'value' implies that
    the value either is unknown, or to be obtained from an external
    source, or determined by an initial assignment.  The unit of
    measurement associated with the value of the parameter can be
    specified using the optional attribute 'units'.  Here we only mention
    briefly some notable points about the possible unit choices, but
    readers are urged to consult the SBML specification documents for more
    information:

    * In SBML Level 3, there are no constraints on the units that can be
    assigned to parameters in a model; there are also no units to inherit
    from the enclosing Model object.

    * In SBML Level 2, the value assigned to the parameter's 'units'
    attribute must be chosen from one of the following possibilities: one
    of the base unit identifiers defined in SBML; one of the built-in unit
    identifiers ''substance',' ''time',' ''volume',' ''area'' or
    ''length';' or the identifier of a new unit defined in the list of
    unit definitions in the enclosing Model structure.  There are no
    constraints on the units that can be chosen from these sets.  There
    are no default units for local parameters. As with all other major
    SBML components, LocalParameter is derived from SBase, and the methods
    defined on SBase are available on LocalParameter.

    In SBML Level 3 Version 2, the scope of the LocalParameter  was
    expanded slightly to officially encompass the entire Reaction instead
    of just the KineticLaw in which it appears.  This has no effect on
    models using only SBML Level 3 Core constructs, but has the potential
    to allow SBML Level 3 Packages to include elements in a Reaction that
    could reference a LocalParameter from that Reaction's KineticLaw.  It
    also means that no LocalParameter may have the same ''id'' as a
    referenced Species in any SimpleSpeciesReference in that Reaction.

    WARNING:

    LibSBML derives LocalParameter from Parameter; however, this does not
    precisely match the object hierarchy defined by SBML Level 3, where
    LocalParameter is derived directly from SBase and not Parameter.  We
    believe this arrangement makes it easier for libSBML users to program
    applications that work with both SBML Level 2 and SBML Level 3, but
    programmers should also keep in mind this difference exists.  A side-
    effect of libSBML's scheme is that certain methods on LocalParameter
    that are inherited from Parameter do not actually have relevance to
    LocalParameter objects.  An example of this is the methods pertaining
    to Parameter's attribute 'constant' (i.e., isSetConstant(),
    setConstant(), and getConstant()).

    See also ListOfLocalParameters, KineticLaw.

    """

    __swig_setmethods__ = {}
    for _s in [Parameter]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LocalParameter, name, value)
    __swig_getmethods__ = {}
    for _s in [Parameter]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, LocalParameter, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_LocalParameter
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(LocalParameter self, unsigned int level, unsigned int version) -> LocalParameter
        __init__(LocalParameter self, SBMLNamespaces sbmlns) -> LocalParameter
        __init__(LocalParameter self, LocalParameter orig) -> LocalParameter
        __init__(LocalParameter self, Parameter orig) -> LocalParameter


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            LocalParameter(SBMLNamespaces sbmlns)

        Creates a new LocalParameter object with the given SBMLNamespaces
        object 'sbmlns'.

        The SBMLNamespaces object encapsulates SBML Level/Version/namespaces
        information.  It is used to communicate the SBML Level, Version, and
        (in Level 3) packages used in addition to SBML Level 3 Core.  A common
        approach to using libSBML's SBMLNamespaces facilities is to create an
        SBMLNamespaces object somewhere in a program once, then hand that
        object as needed to object constructors that accept SBMLNamespaces as
        arguments.

        It is worth emphasizing that although this constructor does not take
        an identifier argument, in SBML Level 2 and beyond, the 'id'
        (identifier) attribute of a LocalParameter is required to have a
        value. Thus, callers are cautioned to assign a value after calling
        this constructor if no identifier is provided as an argument.  Setting
        the identifier can be accomplished using the method setId().

        Parameter 'sbmlns' is an SBMLNamespaces object.

        Throws SBMLConstructorException: Thrown if the given 'sbmlns' is
        inconsistent or incompatible with this object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            LocalParameter(long level, long version)

        Creates a new LocalParameter object with the given SBML 'level' and
        'version' values.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        LocalParameter.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this LocalParameter.

        Throws SBMLConstructorException: Thrown if the given 'level' and
        'version' combination are invalid or if this object is incompatible
        with the given level and version.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            LocalParameter(LocalParameter orig)

        Copy constructor; creates a copy of a given LocalParameter object.

        Parameter 'orig' is the LocalParameter instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            LocalParameter(Parameter orig)

        Copy constructor; creates a LocalParameter object by copying the
        attributes of a given Parameter object.

        Parameter 'orig' is the Parameter instance to copy.

        """
        this = _libsbml.new_LocalParameter(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(LocalParameter self) -> LocalParameter


        Creates and returns a deep copy of this LocalParameter object.

        Returns the (deep) copy of this LocalParameter object.

        """
        return _libsbml.LocalParameter_clone(self)


    def getDerivedUnitDefinition(self, *args):
        """
        getDerivedUnitDefinition(LocalParameter self) -> UnitDefinition
        getDerivedUnitDefinition(LocalParameter self) -> UnitDefinition


        Constructs and returns a UnitDefinition that corresponds to the units
        of this LocalParameter's value.

        LocalParameters in SBML have an attribute ('units') for declaring the
        units of measurement intended for the parameter's value.  No defaults
        are defined by SBML in the absence of a definition for 'units'.  This
        method returns a UnitDefinition object based on the units declared for
        this LocalParameter using its 'units' attribute, or it returns 'None'
        if no units have been declared.

        Note that unit declarations for LocalParameter objects are specified
        in terms of the identifier of a unit (e.g., using setUnits()), but
        this method returns a UnitDefinition object, not a unit identifier.
        It does this by constructing an appropriate UnitDefinition.  For SBML
        Level 2 models, it will do this even when the value of the 'units'
        attribute is one of the predefined SBML units ''substance','
        ''volume',' ''area',' ''length'' or ''time'.'  Callers may find this
        useful in conjunction with the helper methods provided by the
        UnitDefinition class for comparing different UnitDefinition objects.

        Returns a UnitDefinition that expresses the units of this
        LocalParameter, or 'None' if one cannot be constructed.

        Note: The libSBML system for unit analysis depends on the model as a
        whole.  In cases where the LocalParameter object has not yet been
        added to a model, or the model itself is incomplete, unit analysis is
        not possible, and consequently this method will return 'None.'

        See also isSetUnits().

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


    def getTypeCode(self):
        """
        getTypeCode(LocalParameter self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_LOCAL_PARAMETER
        (default).

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.LocalParameter_getTypeCode(self)


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


        Returns the XML element name of this object, which for LocalParameter,
        is always ''localParameter'.'

        Returns the name of this element, i.e., ''localParameter'.'

        """
        return _libsbml.LocalParameter_getElementName(self)


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


        Predicate returning 'True' if all the required attributes for this
        LocalParameter object have been set.

        The required attributes for a LocalParameter object are:

        * 'id'

        * 'value'

        Returns 'True' if the required attributes have been set, 'False'
        otherwise.

        """
        return _libsbml.LocalParameter_hasRequiredAttributes(self)


    def getConstant(self):
        """
        getConstant(LocalParameter self) -> bool


        Internal implementation method.

        """
        return _libsbml.LocalParameter_getConstant(self)


    def isSetConstant(self):
        """
        isSetConstant(LocalParameter self) -> bool


        Internal implementation method.

        """
        return _libsbml.LocalParameter_isSetConstant(self)


    def setConstant(self, flag):
        """
        setConstant(LocalParameter self, bool flag) -> int


        Internal implementation method.

        """
        return _libsbml.LocalParameter_setConstant(self, flag)


    def unsetConstant(self):
        """
        unsetConstant(LocalParameter self) -> int


        Internal implementation method.

        """
        return _libsbml.LocalParameter_unsetConstant(self)

LocalParameter_swigregister = _libsbml.LocalParameter_swigregister
LocalParameter_swigregister(LocalParameter)

class ListOfLocalParameters(ListOfParameters):
    """

    A list of LocalParameter objects.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    """

    __swig_setmethods__ = {}
    for _s in [ListOfParameters]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfLocalParameters, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOfParameters]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfLocalParameters, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ListOfLocalParameters self, unsigned int level, unsigned int version) -> ListOfLocalParameters
        __init__(ListOfLocalParameters self, SBMLNamespaces sbmlns) -> ListOfLocalParameters


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfLocalParameters(SBMLNamespaces sbmlns)

        Creates a new ListOfLocalParameters object.

        The object is constructed such that it is valid for the SBML Level and
        Version combination determined by the SBMLNamespaces object in
        'sbmlns'.

        Parameter 'sbmlns' is an SBMLNamespaces object that is used to
        determine the characteristics of the ListOfLocalParameters object to
        be created.

        Throws SBMLConstructorException: Thrown if the given 'sbmlns' is
        inconsistent or incompatible with this object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfLocalParameters(long level, long version)

        Creates a new ListOfLocalParameters object.

        The object is constructed such that it is valid for the given SBML
        Level and Version combination.

        Parameter 'level' is the SBML Level.

        Parameter 'version' is the Version within the SBML Level.

        Throws SBMLConstructorException: Thrown if the given 'level' and
        'version' combination are invalid or if this object is incompatible
        with the given level and version.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        """
        this = _libsbml.new_ListOfLocalParameters(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ListOfLocalParameters self) -> ListOfLocalParameters


        Creates and returns a deep copy of this ListOfLocalParameters object.

        Returns the (deep) copy of this ListOfLocalParameters object.

        """
        return _libsbml.ListOfLocalParameters_clone(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfLocalParameters self) -> int


        Returns the libSBML type code for the objects contained in this ListOf
        (i.e., LocalParameter objects, if the list is non-empty).

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for the objects contained in this ListOf:
        SBML_LOCAL_PARAMETER (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfLocalParameters_getItemTypeCode(self)


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


        Returns the XML element name of this object.

        For ListOfLocalParameters, the XML element name is
        ''listOfLocalParameters'.'

        Returns the name of this element, i.e., ''listOfLocalParameters'.'

        """
        return _libsbml.ListOfLocalParameters_getElementName(self)


    def get(self, *args):
        """
        get(ListOfLocalParameters self, unsigned int n) -> LocalParameter
        get(ListOfLocalParameters self, unsigned int n) -> LocalParameter
        get(ListOfLocalParameters self, string sid) -> LocalParameter
        get(ListOfLocalParameters self, string sid) -> LocalParameter


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Returns the LocalParameter object located at position 'n' within this
        ListOfLocalParameters instance.

        Parameter 'n' is the index number of the LocalParameter to get.

        Returns the item at position 'n'.  The caller owns the returned object
        and is responsible for deleting it.  If the index number 'n' is out of
        bounds for the length of the list, then 'None' is returned.

        See also size(), get().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Returns the first LocalParameter object matching the given identifier.

        Parameter 'sid' is a string representing the identifier of the
        LocalParameter to get.

        Returns the LocalParameter object found.  The caller owns the returned
        object and is responsible for deleting it.  If none of the items have
        an identifier matching 'sid', then 'None' is returned.

        See also get(), size().

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


    def getElementBySId(self, id):
        """
        getElementBySId(ListOfLocalParameters self, string id) -> SBase


        Returns the first child element found that has the given 'id' in the
        model-wide SId namespace, or 'None' if no such object is found.

        Note that LocalParameters, while they use the SId namespace, are not
        in the model-wide SId namespace, so no LocalParameter object will be
        returned from this function (and is the reason we override the base
        ListOf::getElementBySId function here).

        Parameter 'id' is string representing the id of the object to find.

        Returns pointer to the first element found with the given 'id'.

        """
        return _libsbml.ListOfLocalParameters_getElementBySId(self, id)


    def remove(self, *args):
        """
        remove(ListOfLocalParameters self, unsigned int n) -> LocalParameter
        remove(ListOfLocalParameters self, string sid) -> LocalParameter


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth item from this ListOfLocalParameters, and returns a
        pointer to it.

        Parameter 'n' is the index of the item to remove.

        Returns the item removed.  The caller owns the returned object and is
        responsible for deleting it.  If the index number 'n' is out of bounds
        for the length of the list, then 'None' is returned.

        See also size(), remove().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes the first LocalParameter object in this ListOfLocalParameters
        matching the given identifier, and returns a pointer to it.

        Parameter 'sid' is the identifier of the item to remove.

        Returns the item removed.  The caller owns the returned object and is
        responsible for deleting it.  If none of the items have an identifier
        matching 'sid', then 'None' is returned.

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

    __swig_destroy__ = _libsbml.delete_ListOfLocalParameters
    __del__ = lambda self: None
ListOfLocalParameters_swigregister = _libsbml.ListOfLocalParameters_swigregister
ListOfLocalParameters_swigregister(ListOfLocalParameters)

class InitialAssignment(SBase):
    """

    An SBML initial assignment, evaluated once only.

    SBML Level 2 Versions 2-4 and SBML Level 3 provide two ways of
    assigning initial values to entities in a model.  The simplest and
    most basic is to set the values of the appropriate attributes in the
    relevant components; for example, the initial value of a model
    parameter (whether it is a constant or a variable) can be assigned by
    setting its 'value' attribute directly in the model definition.
    However, this approach is not suitable when the value must be
    calculated, because the initial value attributes on different
    components such as species, compartments, and parameters are single
    values and not mathematical expressions.  In those situations, the
    InitialAssignment construct can be used; it permits the calculation of
    the value of a constant or the initial value of a variable from the
    values of other quantities in a model.

    As explained below, the provision of InitialAssignment does not mean
    that models necessarily must use this construct when defining initial
    values of quantities in a model.  If a value can be set directly using
    the relevant attribute of a component in a model, then that approach
    may be more efficient and more portable to other software tools.
    InitialAssignment should be used when the other mechanism is
    insufficient for the needs of a particular model.

    The InitialAssignment construct has some similarities to
    AssignmentRule. The main differences are: (a) an InitialAssignment can
    set the value of a constant whereas an AssignmentRule cannot, and (b)
    unlike AssignmentRule, an InitialAssignment definition only applies up
    to and including the beginning of simulation time, i.e., t <= 0, while
    an AssignmentRule applies at all times.

    InitialAssignment has a required attribute, 'symbol', whose value must
    follow the guidelines for identifiers described in the SBML
    specification (e.g., Section 3.3 in the Level 2 Version 4
    specification).  The value of this attribute in an InitialAssignment
    object can be the identifier of a Compartment, Species,
    SpeciesReference  (in SBML Level 3),  global Parameter, or (as of SBML
    Level 3 Version 2) the identifier of a SBML Level 3  package element
    with mathematical meaning.  The InitialAssignment defines the initial
    value of the constant or variable referred to by the 'symbol'
    attribute.  (The attribute's name is 'symbol' rather than 'variable'
    because it may assign values to constants as well as variables in a
    model.)  Note that an initial assignment cannot be made to reaction
    identifiers, that is, the 'symbol' attribute value of an
    InitialAssignment cannot be an identifier that is the 'id' attribute
    value of a Reaction object in the model.  This is identical to a
    restriction placed on rules.

    InitialAssignment also has a 'math' subelement that contains a MathML
    expression used to calculate the value of the constant or the initial
    value of the variable.  This subelement is required in SBML Level 2
    and SBML Level 3 Version 1, but the requirement was relaxed in SBML
    Level 3 Version 2, making it optional. The units of the value computed
    by the formula in the 'math' subelement  should (in SBML Level 2
    Version 4 and in SBML Level 3)  or must (in previous Versions) be
    identical to be the units associated with the identifier given in the
    'symbol' attribute. (That is, the units are the units of the species,
    compartment, or parameter, as appropriate for the kind of object
    identified by the value of 'symbol'.)

    InitialAssignment was introduced in SBML Level 2 Version 2.  It is not
    available in SBML Level 2 Version 1 nor in any version of Level 1.

    Semantics of Initial Assignments
    ======================================================================

    The value calculated by an InitialAssignment object overrides the
    value assigned to the given symbol by the object defining that symbol.
    For example, if a compartment's 'size' attribute is set in its
    definition, and the model also contains an InitialAssignment having
    that compartment's identifier as its 'symbol' attribute value, then
    the interpretation is that the 'size' assigned in the Compartment
    object should be ignored and the value assigned based on the
    computation defined in the InitialAssignment.  Initial assignments can
    take place for Compartment, Species, global Parameter,
    SpeciesReference (in  Level 3), and SBML Level 3 package elements (in
    Level 3 Version 2), regardless of the value of their  'constant'
    attribute.

    The actions of all InitialAssignment objects are in general terms the
    same, but differ in the precise details depending on the type of
    variable being set:

    * In the case of a species, an InitialAssignment sets the referenced
    species' initial quantity (concentration or amount of substance) to
    the value determined by the formula in the 'math' subelement.    The
    overall units of the formula should (in SBML Level 2 Version 4 and in
    SBML Level 3) or must (in previous Versions) be the same as the units
    specified for the species.

    * In the case of a compartment, an InitialAssignment sets the
    referenced compartment's initial size to the size determined by the
    formula in 'math'.  The overall units of the formula should (in SBML
    Level 2 Version 4 and in SBML Level 3) or must (in previous Versions)
    be the same as the units specified for the size of the compartment.

    * In the case of a parameter, an InitialAssignment sets the referenced
    parameter's initial value to that determined by the formula in 'math'.
    The overall units of the formula should (in SBML Level 2 Version 4 and
    SBML Level 3) or must (in previous Versions) be the same as the units
    defined for the parameter.

    * (For SBML Level 3 only) In the case of a species reference, an
    initial assignment sets the initial value of the  stoichiometry of the
    referenced reactant or product to the value determined  by the formula
    in 'math'.  The unit associated with the value produced by  the 'math'
    formula should be consistent with the unit 'dimensionless', because
    reactant and product stoichiometries in reactions are dimensionless
    quantities.

    * (For SBML Level 3 Version 2 only) In the case  of an object from an
    SBML Level 3 package, an InitialAssignment  sets the referenced
    object's initial value (however such values are  defined by the
    package) to the value of the formula in math. The unit  of measurement
    associated with the value produced by the formula  should be the same
    as that object's units attribute value (if it has  such an attribute),
    or be equal to the units of model components of  that type (if objects
    of that class are defined by the package as  having the same units).

    If the symbol attribute of an InitialAssignment object references  an
    object in an SBML namespace that is not understood by the  interpreter
    reading a given SBML document (that is, if the object  is defined by
    an SBML Level 3 package that the software does  not support), the
    assignment must be ignored--the object's initial  value will not need
    to be set, as the interpreter could not understand  that package. If
    an interpreter cannot establish whether a referenced  object is
    missing from the model or instead is defined in an SBML  namespace not
    understood by the interpreter, it may produce a  warning to the user.
    (The latter situation may only arise if an SBML  package is present in
    the SBML document with a package:required  attribute of 'true'.)

    In the context of a simulation, initial assignments establish values
    that are in effect prior to and including the start of simulation
    time, i.e., t <= 0.  Section 3.4.8 in the SBML Level 2 Version 4  and
    SBML Level 3 specifications  provides information about the
    interpretation of assignments, rules, and entity values for simulation
    time up to and including the start time t = 0; this is important for
    establishing the initial conditions of a simulation if the model
    involves expressions containing the delay 'csymbol'.

    There cannot be two initial assignments for the same symbol in a
    model; that is, a model must not contain two or more InitialAssignment
    objects that both have the same identifier as their 'symbol' attribute
    value.  A model must also not define initial assignments and
    assignment rules for the same entity.  That is, there cannot be both
    an InitialAssignment and an AssignmentRule for the same symbol in a
    model, because both kinds of constructs apply prior to and at the
    start of simulated time---allowing both to exist for a given symbol
    would result in indeterminism).

    The ordering of InitialAssignment objects is not significant.  The
    combined set of InitialAssignment, AssignmentRule and KineticLaw
    objects form a set of assignment statements that must be considered as
    a whole.  The combined set of assignment statements should not contain
    algebraic loops: a chain of dependency between these statements should
    terminate.  (More formally, consider the directed graph of assignment
    statements where nodes are a model's assignment statements and
    directed arcs exist for each occurrence of a symbol in an assignment
    statement 'math' attribute.  The directed arcs in this graph start
    from the statement assigning the symbol and end at the statement that
    contains the symbol in their math elements.  Such a graph must be
    acyclic.)

    Finally, it is worth being explicit about the expected behavior in the
    following situation.  Suppose (1) a given symbol has a value x
    assigned to it in its definition, and (2) there is an initial
    assignment having the identifier as its 'symbol' value and reassigning
    the value to y, and (3) the identifier is also used in the
    mathematical formula of a second initial assignment.  What value
    should the second initial assignment use?  It is y, the value assigned
    to the symbol by the first initial assignment, not whatever value was
    given in the symbol's definition.  This follows directly from the
    behavior described above: if an InitialAssignment object exists for a
    given symbol, then the symbol's value is overridden by that initial
    assignment.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InitialAssignment, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, InitialAssignment, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_InitialAssignment
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(InitialAssignment self, unsigned int level, unsigned int version) -> InitialAssignment
        __init__(InitialAssignment self, SBMLNamespaces sbmlns) -> InitialAssignment
        __init__(InitialAssignment self, InitialAssignment orig) -> InitialAssignment


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            InitialAssignment(SBMLNamespaces sbmlns)

        Creates a new InitialAssignment using the given SBMLNamespaces object
        'sbmlns'.

        The SBMLNamespaces object encapsulates SBML Level/Version/namespaces
        information.  It is used to communicate the SBML Level, Version, and
        (in Level 3) packages used in addition to SBML Level 3 Core.  A common
        approach to using libSBML's SBMLNamespaces facilities is to create an
        SBMLNamespaces object somewhere in a program once, then hand that
        object as needed to object constructors that accept SBMLNamespaces as
        arguments.

        Parameter 'sbmlns' is an SBMLNamespaces object.

        Throws SBMLConstructorException: Thrown if the given 'sbmlns' is
        inconsistent or incompatible with this object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            InitialAssignment(long level, long version)

        Creates a new InitialAssignment using the given SBML 'level' and
        'version' values.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        InitialAssignment.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this InitialAssignment.

        Throws SBMLConstructorException: Thrown if the given 'level' and
        'version' combination are invalid or if this object is incompatible
        with the given level and version.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            InitialAssignment(InitialAssignment orig)

        Copy constructor; creates a copy of this InitialAssignment.

        Parameter 'orig' is the object to copy.

        """
        this = _libsbml.new_InitialAssignment(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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


        Creates and returns a deep copy of this InitialAssignment object.

        Returns the (deep) copy of this InitialAssignment object.

        """
        return _libsbml.InitialAssignment_clone(self)


    def getSymbol(self):
        """
        getSymbol(InitialAssignment self) -> string


        Get the value of the 'symbol' attribute of this InitialAssignment.

        Returns the identifier string stored as the 'symbol' attribute value
        in this InitialAssignment.

        """
        return _libsbml.InitialAssignment_getSymbol(self)


    def getMath(self):
        """
        getMath(InitialAssignment self) -> ASTNode


        Get the mathematical formula of this InitialAssignment.

        Returns an ASTNode, the value of the 'math' subelement of this
        InitialAssignment, or 'None' if the math is not set.

        """
        return _libsbml.InitialAssignment_getMath(self)


    def isSetSymbol(self):
        """
        isSetSymbol(InitialAssignment self) -> bool


        Predicate returning 'True' if this InitialAssignment's 'symbol'
        attribute is set.

        Returns 'True' if the 'symbol' attribute of this InitialAssignment is
        set, 'False' otherwise.

        """
        return _libsbml.InitialAssignment_isSetSymbol(self)


    def isSetMath(self):
        """
        isSetMath(InitialAssignment self) -> bool


        Predicate returning 'True' if this InitialAssignment's 'math'
        subelement contains a value.

        Returns 'True' if the 'math' for this InitialAssignment is set,
        'False' otherwise.

        """
        return _libsbml.InitialAssignment_isSetMath(self)


    def setSymbol(self, sid):
        """
        setSymbol(InitialAssignment self, string sid) -> int


        Sets the 'symbol' attribute value of this InitialAssignment.

        Parameter 'sid' is the identifier of an element defined in this model
        whose value can be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.InitialAssignment_setSymbol(self, sid)


    def unsetSymbol(self):
        """
        unsetSymbol(InitialAssignment self) -> int


        Unsets the 'symbol' attribute value of this InitialAssignment.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.InitialAssignment_unsetSymbol(self)


    def setMath(self, math):
        """
        setMath(InitialAssignment self, ASTNode math) -> int


        Sets the 'math' subelement of this InitialAssignment.

        The AST passed in 'math' is copied.

        Parameter 'math' is an AST containing the mathematical expression to
        be used as the formula for this InitialAssignment.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_OBJECT

        """
        return _libsbml.InitialAssignment_setMath(self, math)


    def getDerivedUnitDefinition(self, *args):
        """
        getDerivedUnitDefinition(InitialAssignment self) -> UnitDefinition
        getDerivedUnitDefinition(InitialAssignment self) -> UnitDefinition


        Calculates and returns a UnitDefinition that expresses the units of
        measurement assumed for the 'math' expression of this
        InitialAssignment.

        The units are calculated based on the mathematical expression in the
        InitialAssignment and the model quantities referenced by <ci> elements
        used within that expression.  The method
        InitialAssignment.getDerivedUnitDefinition() returns the calculated
        units, to the extent that libSBML can compute them.

        Note: The functionality that facilitates unit analysis depends on the
        model as a whole.  Thus, in cases where the object has not been added
        to a model or the model itself is incomplete, unit analysis is not
        possible and this method will return 'None.'

        WARNING:

        Note that it is possible the 'math' expression in the
        InitialAssignment contains literal numbers or parameters with
        undeclared units.  In those cases, it is not possible to calculate the
        units of the overall expression without making assumptions.  LibSBML
        does not make assumptions about the units, and
        InitialAssignment.getDerivedUnitDefinition() only returns the units as
        far as it is able to determine them.  For example, in an expression X
        + Y, if X has unambiguously-defined units and Y does not, it will
        return the units of X.  When using this method, it is critical that
        callers also invoke the method
        InitialAssignment.containsUndeclaredUnits() to determine whether this
        situation holds.  Callers should take suitable action in those
        situations.

        Returns a UnitDefinition that expresses the units of the math
        expression of this InitialAssignment, or 'None' if one cannot be
        constructed.

        See also containsUndeclaredUnits().

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


    def containsUndeclaredUnits(self, *args):
        """
        containsUndeclaredUnits(InitialAssignment self) -> bool
        containsUndeclaredUnits(InitialAssignment self) -> bool


        Predicate returning 'True' if the math expression of this
        InitialAssignment contains parameters/numbers with undeclared units.

        Returns 'True' if the math expression of this InitialAssignment
        includes parameters/numbers  with undeclared units, 'False' otherwise.

        Note: A return value of 'True' indicates that the UnitDefinition
        returned by InitialAssignment::getDerivedUnitDefinition may not
        accurately represent the units of the expression.

        See also getDerivedUnitDefinition().

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


    def getTypeCode(self):
        """
        getTypeCode(InitialAssignment self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_INITIAL_ASSIGNMENT
        (default).

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.InitialAssignment_getTypeCode(self)


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


        Returns the XML element name of this object, which for
        InitialAssignment, is always ''initialAssignment'.'

        Returns the name of this element, i.e., ''initialAssignment'.'

        """
        return _libsbml.InitialAssignment_getElementName(self)


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


        Predicate returning 'True' if all the required attributes for this
        InitialAssignment object have been set.

        The required attributes for an InitialAssignment object are:

        * 'symbol'

        Returns 'True' if the required attributes have been set, 'False'
        otherwise.

        """
        return _libsbml.InitialAssignment_hasRequiredAttributes(self)


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


        Predicate returning 'True' if all the required elements for this
        InitialAssignment object have been set.

        Note: The required elements for a InitialAssignment object are:

        * 'math' inSBML Level 2 and Level 3 Version 1.   (In SBML Level 3
        Version 2+, it is no longer required.)

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

        """
        return _libsbml.InitialAssignment_hasRequiredElements(self)


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


        Returns the value of the 'symbol' attribute of this InitialAssignment
        (NOT the 'id').

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is now recommended to use the
        getIdAttribute() or InitialAssignment.getSymbol()  functions instead.

        The 'symbol' attribute of an InitialAssignment indicates the element
        which the results of the 'math' are to be applied.

        Returns the symbol of this InitialAssignment.

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute(), getSymbol().

        """
        return _libsbml.InitialAssignment_getId(self)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(InitialAssignment self, string oldid, string newid)


        Replaces all uses of a given 'SIdRef' type attribute value with
        another value.

        In SBML, object identifiers are of a data type called SId. In SBML
        Level 3, an explicit data type called SIdRef was introduced for
        attribute values that refer to SId values; in previous Levels of SBML,
        this data type did not exist and attributes were simply described to
        as 'referring to an identifier', but the effective data type was the
        same as SIdRef in Level 3.  These and other methods of libSBML refer
        to the type SIdRef for all Levels of SBML, even if the corresponding
        SBML specification did not explicitly name the data type.

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas in MathML content, comparing the referenced
        identifiers to the value of 'oldid'.  If any matches are found, the
        matching values are replaced with 'newid'.  The method does not
        descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.InitialAssignment_renameSIdRefs(self, oldid, newid)


    def renameUnitSIdRefs(self, oldid, newid):
        """
        renameUnitSIdRefs(InitialAssignment self, string oldid, string newid)


        Replaces all uses of a given 'UnitSIdRef' type attribute value with
        another value.

        In SBML, unit definitions have identifiers of type UnitSId.  In SBML
        Level 3, an explicit data type called UnitSIdRef was introduced for
        attribute values that refer to UnitSId values; in previous Levels of
        SBML, this data type did not exist and attributes were simply
        described to as 'referring to a unit identifier', but the effective
        data type was the same as UnitSIdRef in Level 3.  These and other
        methods of libSBML refer to the type UnitSIdRef for all Levels of
        SBML, even if the corresponding SBML specification did not explicitly
        name the data type.

        This method works by looking at all unit identifier attribute values
        (including, if appropriate, inside mathematical formulas), comparing
        the referenced unit identifiers to the value of 'oldid'.  If any
        matches are found, the matching values are replaced with 'newid'.  The
        method does not descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.InitialAssignment_renameUnitSIdRefs(self, oldid, newid)


    def replaceSIDWithFunction(self, id, function):
        """
        replaceSIDWithFunction(InitialAssignment self, string id, ASTNode function)


        Internal implementation method.

        """
        return _libsbml.InitialAssignment_replaceSIDWithFunction(self, id, function)


    def divideAssignmentsToSIdByFunction(self, id, function):
        """
        divideAssignmentsToSIdByFunction(InitialAssignment self, string id, ASTNode function)


        Internal implementation method.

        """
        return _libsbml.InitialAssignment_divideAssignmentsToSIdByFunction(self, id, function)


    def multiplyAssignmentsToSIdByFunction(self, id, function):
        """
        multiplyAssignmentsToSIdByFunction(InitialAssignment self, string id, ASTNode function)


        Internal implementation method.

        """
        return _libsbml.InitialAssignment_multiplyAssignmentsToSIdByFunction(self, id, function)

InitialAssignment_swigregister = _libsbml.InitialAssignment_swigregister
InitialAssignment_swigregister(InitialAssignment)

class ListOfInitialAssignments(ListOf):
    """

    A list of InitialAssignment objects.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfInitialAssignments, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfInitialAssignments, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ListOfInitialAssignments self, unsigned int level, unsigned int version) -> ListOfInitialAssignments
        __init__(ListOfInitialAssignments self, SBMLNamespaces sbmlns) -> ListOfInitialAssignments


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfInitialAssignments(SBMLNamespaces sbmlns)

        Creates a new ListOfInitialAssignments object.

        The object is constructed such that it is valid for the SBML Level and
        Version combination determined by the SBMLNamespaces object in
        'sbmlns'.

        Parameter 'sbmlns' is an SBMLNamespaces object that is used to
        determine the characteristics of the ListOfInitialAssignments object
        to be created.

        Throws SBMLConstructorException: Thrown if the given 'sbmlns' is
        inconsistent or incompatible with this object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfInitialAssignments(long level, long version)

        Creates a new ListOfInitialAssignments object.

        The object is constructed such that it is valid for the given SBML
        Level and Version combination.

        Parameter 'level' is the SBML Level.

        Parameter 'version' is the Version within the SBML Level.

        Throws SBMLConstructorException: Thrown if the given 'level' and
        'version' combination are invalid or if this object is incompatible
        with the given level and version.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        """
        this = _libsbml.new_ListOfInitialAssignments(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ListOfInitialAssignments self) -> ListOfInitialAssignments


        Creates and returns a deep copy of this ListOfInitialAssignments
        object.

        Returns the (deep) copy of this ListOfInitialAssignments object.

        """
        return _libsbml.ListOfInitialAssignments_clone(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfInitialAssignments self) -> int


        Returns the libSBML type code for the objects contained in this ListOf
        (i.e., InitialAssignment objects, if the list is non-empty).

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for the objects contained in this ListOf:
        SBML_INITIAL_ASSIGNMENT (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfInitialAssignments_getItemTypeCode(self)


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


        Returns the XML element name of this object.

        For ListOfInitialAssignments, the XML element name is
        ''listOfInitialAssignments'.'

        Returns the name of this element, i.e., ''listOfInitialAssignments'.'

        """
        return _libsbml.ListOfInitialAssignments_getElementName(self)


    def get(self, *args):
        """
        get(ListOfInitialAssignments self, unsigned int n) -> InitialAssignment
        get(ListOfInitialAssignments self, unsigned int n) -> InitialAssignment
        get(ListOfInitialAssignments self, string sid) -> InitialAssignment
        get(ListOfInitialAssignments self, string sid) -> InitialAssignment


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a InitialAssignment from the ListOfInitialAssignments.

        Parameter 'n' is the index number of the InitialAssignment to get.

        Returns the nth InitialAssignment in this ListOfInitialAssignments. If
        the index 'n' is invalid, 'None' is returned.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a InitialAssignment from the ListOfInitialAssignments based on its
        identifier.

        Parameter 'sid' is a string representing the identifier  of the
        InitialAssignment to get.

        Returns InitialAssignment in this ListOfInitialAssignments with the
        given 'sid' or 'None' if no such InitialAssignment exists.

        See also get(), size().

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


    def remove(self, *args):
        """
        remove(ListOfInitialAssignments self, unsigned int n) -> InitialAssignment
        remove(ListOfInitialAssignments self, string sid) -> InitialAssignment


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth item from this ListOfInitialAssignments items and
        returns a pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the item to remove.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes item in this ListOfInitialAssignments 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 'sid', then
        'None' is returned.

        Parameter 'sid' is the identifier of the item to remove.

        Returns the item removed.  As mentioned above, the caller owns the
        returned item.

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


    def getElementBySId(self, id):
        """
        getElementBySId(ListOfInitialAssignments self, string id) -> SBase


        Returns the first child element found that has the given 'id' in the
        model-wide SId namespace, or 'None' if no such object is found.

        Note that InitialAssignments do not actually have IDs, though the
        libsbml interface pretends that they do: no initial assignment is
        returned by this function.

        Parameter 'id' is string representing the id of the object to find.

        Returns pointer to the first element found with the given 'id'.

        """
        return _libsbml.ListOfInitialAssignments_getElementBySId(self, id)

    __swig_destroy__ = _libsbml.delete_ListOfInitialAssignments
    __del__ = lambda self: None
ListOfInitialAssignments_swigregister = _libsbml.ListOfInitialAssignments_swigregister
ListOfInitialAssignments_swigregister(ListOfInitialAssignments)

RULE_TYPE_RATE = _libsbml.RULE_TYPE_RATE
RULE_TYPE_SCALAR = _libsbml.RULE_TYPE_SCALAR
RULE_TYPE_INVALID = _libsbml.RULE_TYPE_INVALID
class Rule(SBase):
    """

    Parent class for SBML rules in libSBML.

    In SBML, rules provide additional ways to define the values of
    variables in a model, their relationships, and the dynamical behaviors
    of those variables.  They enable encoding relationships that cannot be
    expressed using Reaction nor InitialAssignment objects alone.

    The libSBML implementation of rules mirrors the SBML Level 3
    definition (which is in turn is very similar to the Level 2 Version 4
    definition), with Rule being the parent class of three subclasses as
    explained below.  The Rule class itself cannot be instantiated by user
    programs and has no constructor; only the subclasses AssignmentRule,
    AlgebraicRule and RateRule can be instantiated directly.

    General summary of SBML rules
    ======================================================================

    In SBML Level 3 as well as Level 2, rules are separated into three
    subclasses for the benefit of model analysis software.  The three
    subclasses are based on the following three different possible
    functional forms (where x is a variable, f is some arbitrary function
    returning a numerical result, V is a vector of variables that does not
    include x, and W is a vector of variables that may include x):

       Algebraic:   left-hand side is zero               0 = f(W)     
       Assignment:  left-hand side is a scalar:          x = f(V)     
       Rate:        left-hand side is a rate-of-change:  dx/dt = f(W)

    In their general form given above, there is little to distinguish
    between assignment and algebraic rules.  They are treated as separate
    cases for the following reasons:

    * Assignment rules can simply be evaluated to calculate
    intermediate values for use in numerical methods.  They are statements
    of equality that hold at all times.  (For assignments that are only
    performed once, see InitialAssignment.)

    * SBML needs to place restrictions on assignment rules, for example
    the restriction that assignment rules cannot contain algebraic loops.

    * Some simulators do not contain numerical solvers capable of
    solving unconstrained algebraic equations, and providing more direct
    forms such as assignment rules may enable those simulators to process
    models they could not process if the same assignments were put in the
    form of general algebraic equations;

    * Those simulators that can solve these algebraic equations make a
    distinction between the different categories listed above; and

    * Some specialized numerical analyses of models may only be
    applicable to models that do not contain algebraic rules.

    The approach taken to covering these cases in SBML is to define an
    abstract Rule structure containing a subelement, 'math', to hold the
    right-hand side expression, then to derive subtypes of Rule that add
    attributes to distinguish the cases of algebraic, assignment and rate
    rules.  The 'math' subelement must contain a MathML expression
    defining the mathematical formula of the rule.  This MathML formula
    must return a numerical value.  The formula can be an arbitrary
    expression referencing the variables and other entities in an SBML
    model.

    Each of the three subclasses of Rule (AssignmentRule, AlgebraicRule,
    RateRule) inherit the the 'math' subelement and other fields from
    SBase. The AssignmentRule and RateRule classes add an additional
    attribute, 'variable'.  See the definitions of AssignmentRule,
    AlgebraicRule and RateRule for details about the structure and
    interpretation of each one.

    Additional restrictions on SBML rules
    ======================================================================

    An important design goal of SBML rule semantics is to ensure that a
    model's simulation and analysis results will not be dependent on when
    or how often rules are evaluated.  To achieve this, SBML needs to
    place two restrictions on rule use.  The first concerns algebraic
    loops in the system of assignments in a model, and the second concerns
    overdetermined systems.

    A model must not contain algebraic loops
    ......................................................................

    The combined set of InitialAssignment, AssignmentRule and KineticLaw
    objects in a model constitute a set of assignment statements that
    should be considered as a whole.  (A KineticLaw object is counted as
    an assignment because it assigns a value to the symbol contained in
    the 'id' attribute of the Reaction object in which it is defined.)
    This combined set of assignment statements must not contain algebraic
    loops---dependency chains between these statements must terminate.  To
    put this more formally, consider a directed graph in which nodes are
    assignment statements and directed arcs exist for each occurrence of
    an SBML species, compartment or parameter symbol in an assignment
    statement's 'math' subelement.  Let the directed arcs point from the
    statement assigning the symbol to the statements that contain the
    symbol in their 'math' subelement expressions. This graph must be
    acyclic.

    Similarly, the combined set of RateRule and Reaction objects
    constitute  a set of definitions for the rates of change of various
    model entities  (namely, the objects identified by the values of the
    'variable' attributes  of the RateRule objects, and the 'species'
    attributes of the SpeciesReference  objects in each Reaction).  In
    SBML Level 3 Version 2, these rates  of change may be referenced
    directly  using the rateOf csymbol, but may not thereby contain
    algebraic  loops---dependency chains between these statements must
    terminate.  More  formally, consider a directed graph in which the
    nodes are the definitions  of different variables' rates of change,
    and directed arcs exist for each  occurrence of a variable referenced
    by a rateOf csymbol from any  RateRule or KineticLaw object in the
    model.  Let the directed arcs point  from the variable referenced by
    the rateOf csymbol (call it  x) to the variable(s) determined by the
    'math' expression in which x appears.  This graph must be acyclic.

    SBML does not specify when or how often rules should be evaluated.
    Eliminating algebraic loops ensures that assignment statements can be
    evaluated any number of times without the result of those evaluations
    changing.  As an example, consider the set of equations x = x + 1, y =
    z + 200 and z = y + 100.  If this set of equations were interpreted as
    a set of assignment statements, it would be invalid because the rule
    for x refers to x (exhibiting one type of loop), and the rule for y
    refers to z while the rule for z refers back to y (exhibiting another
    type of loop). Conversely, the following set of equations would
    constitute a valid set of assignment statements: x = 10, y = z + 200,
    and z = x + 100.

    A model must not be overdetermined
    ......................................................................

    An SBML model must not be overdetermined; that is, a model must not
    define more equations than there are unknowns in a model.  A valid
    SBML model that does not contain AlgebraicRule structures cannot be
    overdetermined.

    LibSBML implements the static analysis procedure described in Appendix
    B of the SBML Level 3 specification for assessing whether a model is
    overdetermined.

    (In summary, assessing whether a given continuous, deterministic,
    mathematical model is overdetermined does not require dynamic
    analysis; it can be done by analyzing the system of equations created
    from the model. One approach is to construct a bipartite graph in
    which one set of vertices represents the variables and the other the
    set of vertices represents the equations.  Place edges between
    vertices such that variables in the system are linked to the equations
    that determine them.  For algebraic equations, there will be edges
    between the equation and each variable occurring in the equation.  For
    ordinary differential equations (such as those defined by rate rules
    or implied by the reaction rate definitions), there will be a single
    edge between the equation and the variable determined by that
    differential equation.  A mathematical model is overdetermined if the
    maximal matchings of the bipartite graph contain disconnected vertexes
    representing equations.  If one maximal matching has this property,
    then all the maximal matchings will have this property; i.e., it is
    only necessary to find one maximal matching.)

    Rule types for SBML Level 1
    ======================================================================

    SBML Level 1 uses a different scheme than SBML Level 2 and Level 3 for
    distinguishing rules; specifically, it uses an attribute whose value
    is drawn from an enumeration of 3 values.  LibSBML supports this using
    methods that work with the enumeration values  listed below.

    * RULE_TYPE_RATE: Indicates the rule is a 'rate' rule.

    * RULE_TYPE_SCALAR: Indicates the rule is a 'scalar' rule.

    * RULE_TYPE_INVALID: Indicates the rule type is unknown or not yet
    set.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Rule, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Rule, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_Rule
    __del__ = lambda self: None

    def __init__(self, orig):
        """
        __init__(Rule self, Rule orig) -> Rule


        @internal

        """
        this = _libsbml.new_Rule(orig)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(Rule self) -> Rule


        Creates and returns a deep copy of this Rule object.

        Returns the (deep) copy of this Rule object.

        """
        return _libsbml.Rule_clone(self)


    def getFormula(self):
        """
        getFormula(Rule self) -> string


        Returns the mathematical expression of this Rule in text-string form.

        The text string is produced by SBML_formulaToString(); please consult
        the documentation for that function to find out more about the format
        of the text-string formula.

        Returns the formula text string for this Rule.

        Note: The attribute 'formula' is specific to SBML Level 1; in higher
        Levels of SBML, it has been replaced with a subelement named 'math'.
        However, libSBML provides a unified interface to the underlying math
        expression and this method can be used for models of all Levels of
        SBML.

        See also getMath().

        """
        return _libsbml.Rule_getFormula(self)


    def getMath(self):
        """
        getMath(Rule self) -> ASTNode


        Get the mathematical formula of this Rule as an ASTNode tree.

        Returns an ASTNode, the value of the 'math' subelement of this Rule,
        or 'None' if the math is not set.

        Note: The subelement 'math' is present in SBML Levels 2 and 3.  In
        SBML Level 1, the equivalent construct is the attribute named
        'formula'.  LibSBML provides a unified interface to the underlying
        math expression and this method can be used for models of all Levels
        of SBML.

        See also getFormula().

        """
        return _libsbml.Rule_getMath(self)


    def getVariable(self):
        """
        getVariable(Rule self) -> string


        Get the value of the 'variable' attribute of this Rule object.

        In SBML Level 1, the different rule types each have a different name
        for the attribute holding the reference to the object constituting the
        left-hand side of the rule.  (E.g., for SBML Level 1's
        SpeciesConcentrationRule the attribute is 'species', for
        CompartmentVolumeRule it is 'compartment', etc.)  In SBML Levels 2 and
        3, the only two types of Rule objects with a left-hand side object
        reference are AssignmentRule and RateRule, and both of them use the
        same name for attribute: 'variable'.  In order to make it easier for
        application developers to work with all Levels of SBML, libSBML uses a
        uniform name for all such attributes, and it is 'variable', regardless
        of whether Level 1 rules or Level 2-3 rules are being used.

        The 'variable' attribute of a Rule indicates the element which the
        results of the 'math' are to be applied.  An AlgebraicRule has no
        'variable', and will always return an empty string.

        Returns the identifier string stored as the 'variable' attribute value
        in this Rule, or 'None' if this object is an AlgebraicRule object, or
        if  the attribute is unset.

        """
        return _libsbml.Rule_getVariable(self)


    def getUnits(self):
        """
        getUnits(Rule self) -> string


        Returns the units for the mathematical formula of this Rule.

        Returns the identifier of the units for the expression of this Rule.

        Note: The attribute 'units' exists on SBML Level 1 ParameterRule
        objects only.  It is not present in SBML Levels 2 and 3.

        """
        return _libsbml.Rule_getUnits(self)


    def isSetFormula(self):
        """
        isSetFormula(Rule self) -> bool


        Predicate returning 'True' if this Rule's mathematical expression is
        set.

        This method is equivalent to isSetMath().  This version is present for
        easier compatibility with SBML Level 1, in which mathematical formulas
        were written in text-string form.

        Returns 'True' if the mathematical formula for this Rule is set,
        'False' otherwise.

        Note: The attribute 'formula' is specific to SBML Level 1; in higher
        Levels of SBML, it has been replaced with a subelement named 'math'.
        However, libSBML provides a unified interface to the underlying math
        expression and this method can be used for models of all Levels of
        SBML.

        See also isSetMath().

        """
        return _libsbml.Rule_isSetFormula(self)


    def isSetMath(self):
        """
        isSetMath(Rule self) -> bool


        Predicate returning 'True' if this Rule's mathematical expression is
        set.

        This method is equivalent to isSetFormula().

        Returns 'True' if the formula (or equivalently the math) for this Rule
        is set, 'False' otherwise.

        Note: The subelement 'math' is present in SBML Levels 2 and 3.  In
        SBML Level 1, the equivalent construct is the attribute named
        'formula'.  LibSBML provides a unified interface to the underlying
        math expression and this method can be used for models of all Levels
        of SBML.

        See also isSetFormula().

        """
        return _libsbml.Rule_isSetMath(self)


    def isSetVariable(self):
        """
        isSetVariable(Rule self) -> bool


        Predicate returning 'True' if this Rule's 'variable' attribute is set.

        In SBML Level 1, the different rule types each have a different name
        for the attribute holding the reference to the object constituting the
        left-hand side of the rule.  (E.g., for SBML Level 1's
        SpeciesConcentrationRule the attribute is 'species', for
        CompartmentVolumeRule it is 'compartment', etc.)  In SBML Levels 2 and
        3, the only two types of Rule objects with a left-hand side object
        reference are AssignmentRule and RateRule, and both of them use the
        same name for attribute: 'variable'.  In order to make it easier for
        application developers to work with all Levels of SBML, libSBML uses a
        uniform name for all such attributes, and it is 'variable', regardless
        of whether Level 1 rules or Level 2-3 rules are being used.

        Returns 'True' if the 'variable' attribute value of this Rule is set,
        'False' otherwise.

        """
        return _libsbml.Rule_isSetVariable(self)


    def isSetUnits(self):
        """
        isSetUnits(Rule self) -> bool


        Predicate returning 'True' if this Rule's 'units' attribute is set.

        Returns 'True' if the units for this Rule is set, 'False' otherwise.

        Note: The attribute 'units' exists on SBML Level 1 ParameterRule
        objects only.  It is not present in SBML Levels 2 and 3.

        """
        return _libsbml.Rule_isSetUnits(self)


    def setFormula(self, formula):
        """
        setFormula(Rule self, string formula) -> int


        Sets the 'math' subelement of this Rule to an expression in text-
        string form.

        This is equivalent to setMath(ASTNode math).  The provision of using
        text-string formulas is retained for easier SBML Level 1
        compatibility.  The formula is converted to an ASTNode internally.

        Parameter 'formula' is a mathematical formula in text-string form.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_OBJECT

        Note: The attribute 'formula' is specific to SBML Level 1; in higher
        Levels of SBML, it has been replaced with a subelement named 'math'.
        However, libSBML provides a unified interface to the underlying math
        expression and this method can be used for models of all Levels of
        SBML.

        See also setMath().

        """
        return _libsbml.Rule_setFormula(self, formula)


    def setMath(self, math):
        """
        setMath(Rule self, ASTNode math) -> int


        Sets the 'math' subelement of this Rule to a copy of the given
        ASTNode.

        Parameter 'math' is the AST structure of the mathematical formula.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_OBJECT

        Note: The subelement 'math' is present in SBML Levels 2 and 3.  In
        SBML Level 1, the equivalent construct is the attribute named
        'formula'.  LibSBML provides a unified interface to the underlying
        math expression and this method can be used for models of all Levels
        of SBML.

        See also setFormula().

        """
        return _libsbml.Rule_setMath(self, math)


    def setVariable(self, sid):
        """
        setVariable(Rule self, string sid) -> int


        Sets the 'variable' attribute value of this Rule object.

        In SBML Level 1, the different rule types each have a different name
        for the attribute holding the reference to the object constituting the
        left-hand side of the rule.  (E.g., for SBML Level 1's
        SpeciesConcentrationRule the attribute is 'species', for
        CompartmentVolumeRule it is 'compartment', etc.)  In SBML Levels 2 and
        3, the only two types of Rule objects with a left-hand side object
        reference are AssignmentRule and RateRule, and both of them use the
        same name for attribute: 'variable'.  In order to make it easier for
        application developers to work with all Levels of SBML, libSBML uses a
        uniform name for all such attributes, and it is 'variable', regardless
        of whether Level 1 rules or Level 2-3 rules are being used.

        Parameter 'sid' is the identifier of a Compartment, Species or
        Parameter elsewhere in the enclosing Model object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        """
        return _libsbml.Rule_setVariable(self, sid)


    def setUnits(self, sname):
        """
        setUnits(Rule self, string sname) -> int


        Sets the units for this Rule.

        Parameter 'sname' is the identifier of the units.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        Note: The attribute 'units' exists on SBML Level 1 ParameterRule
        objects only.  It is not present in SBML Levels 2 and 3.

        """
        return _libsbml.Rule_setUnits(self, sname)


    def unsetVariable(self):
        """
        unsetVariable(Rule self) -> int


        Unsets the value of the 'variable' attribute of this Rule object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        See also setVariable(), isSetVariable(), getVariable().

        """
        return _libsbml.Rule_unsetVariable(self)


    def unsetUnits(self):
        """
        unsetUnits(Rule self) -> int


        Unsets the 'units' for this Rule.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        Note: The attribute 'units' exists on SBML Level 1 ParameterRule
        objects only.  It is not present in SBML Levels 2 and 3.

        """
        return _libsbml.Rule_unsetUnits(self)


    def getDerivedUnitDefinition(self, *args):
        """
        getDerivedUnitDefinition(Rule self) -> UnitDefinition
        getDerivedUnitDefinition(Rule self) -> UnitDefinition


        Calculates and returns a UnitDefinition that expresses the units of
        measurement assumed for the 'math' expression of this Rule.

        The units are calculated based on the mathematical expression in the
        Rule and the model quantities referenced by <ci> elements used within
        that expression.  The method Rule.getDerivedUnitDefinition() returns
        the calculated units, to the extent that libSBML can compute them.

        Note: The functionality that facilitates unit analysis depends on the
        model as a whole.  Thus, in cases where the object has not been added
        to a model or the model itself is incomplete, unit analysis is not
        possible and this method will return 'None.'

        WARNING:

        Note that it is possible the 'math' expression in the Rule contains
        pure numbers or parameters with undeclared units.  In those cases, it
        is not possible to calculate the units of the overall expression
        without making assumptions.  LibSBML does not make assumptions about
        the units, and Rule.getDerivedUnitDefinition() only returns the units
        as far as it is able to determine them.  For example, in an expression
        X + Y, if X has unambiguously-defined units and Y does not, it will
        return the units of X. It is important that callers also invoke the
        method Rule.containsUndeclaredUnits() to determine whether this
        situation holds.  Callers may wish to take suitable actions in those
        scenarios.

        Returns a UnitDefinition that expresses the units of the math
        expression of this Rule, or 'None' if one cannot be constructed.

        See also containsUndeclaredUnits().

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


    def containsUndeclaredUnits(self, *args):
        """
        containsUndeclaredUnits(Rule self) -> bool
        containsUndeclaredUnits(Rule self) -> bool


        Predicate returning 'True' if the math expression of this Rule
        contains parameters/numbers with undeclared units.

        Returns 'True' if the math expression of this Rule includes
        parameters/numbers with undeclared units, 'False' otherwise.

        Note: A return value of 'True' indicates that the UnitDefinition
        returned by getDerivedUnitDefinition() may not accurately represent
        the units of the expression.

        See also getDerivedUnitDefinition().

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


    def getType(self):
        """
        getType(Rule self) -> RuleType_t


        Returns a code representing the type of rule this is.

        Returns the rule type, which will be one of the following three
        possible values:

        * RULE_TYPE_RATE

        * RULE_TYPE_SCALAR

        * RULE_TYPE_INVALID

        Note: The attribute 'type' on Rule objects is present only in SBML
        Level 1.  In SBML Level 2 and later, the type has been replaced by
        subclassing the Rule object.

        """
        return _libsbml.Rule_getType(self)


    def isAlgebraic(self):
        """
        isAlgebraic(Rule self) -> bool


        Predicate returning 'True' if this Rule is an AlgebraicRule.

        Returns 'True' if this Rule is an AlgebraicRule, 'False' otherwise.

        """
        return _libsbml.Rule_isAlgebraic(self)


    def isAssignment(self):
        """
        isAssignment(Rule self) -> bool


        Predicate returning 'True' if this Rule is an AssignmentRule.

        Returns 'True' if this Rule is an AssignmentRule, 'False' otherwise.

        """
        return _libsbml.Rule_isAssignment(self)


    def isCompartmentVolume(self):
        """
        isCompartmentVolume(Rule self) -> bool


        Predicate returning 'True' if this Rule is an CompartmentVolumeRule or
        equivalent.

        This libSBML method works for SBML Level 1 models (where there is such
        a thing as an explicit CompartmentVolumeRule), as well as other Levels
        of SBML.  For Levels above Level 1, this method checks the symbol
        being affected by the rule, and returns 'True' if the symbol is the
        identifier of a Compartment object defined in the model.

        Returns 'True' if this Rule is a CompartmentVolumeRule, 'False'
        otherwise.

        """
        return _libsbml.Rule_isCompartmentVolume(self)


    def isParameter(self):
        """
        isParameter(Rule self) -> bool


        Predicate returning 'True' if this Rule is an ParameterRule or
        equivalent.

        This libSBML method works for SBML Level 1 models (where there is such
        a thing as an explicit ParameterRule), as well as other Levels of
        SBML.  For Levels above Level 1, this method checks the symbol being
        affected by the rule, and returns 'True' if the symbol is the
        identifier of a Parameter object defined in the model.

        Returns 'True' if this Rule is a ParameterRule, 'False' otherwise.

        """
        return _libsbml.Rule_isParameter(self)


    def isRate(self):
        """
        isRate(Rule self) -> bool


        Predicate returning 'True' if this Rule is a RateRule (SBML Levels
        2-3) or has a 'type' attribute value of ''rate'' (SBML Level 1).

        Returns 'True' if this Rule is a RateRule (Level 2) or has type 'rate'
        (Level 1), 'False' otherwise.

        """
        return _libsbml.Rule_isRate(self)


    def isScalar(self):
        """
        isScalar(Rule self) -> bool


        Predicate returning 'True' if this Rule is an AssignmentRule (SBML
        Levels 2-3) or has a 'type' attribute value of ''scalar'' (SBML Level
        1).

        Returns 'True' if this Rule is an AssignmentRule (Level 2) or has type
        'scalar' (Level 1), 'False' otherwise.

        """
        return _libsbml.Rule_isScalar(self)


    def isSpeciesConcentration(self):
        """
        isSpeciesConcentration(Rule self) -> bool


        Predicate returning 'True' if this Rule is a SpeciesConcentrationRule
        or equivalent.

        This libSBML method works for SBML Level 1 models (where there is such
        a thing as an explicit SpeciesConcentrationRule), as well as other
        Levels of SBML.  For Levels above Level 1, this method checks the
        symbol being affected by the rule, and returns 'True' if the symbol is
        the identifier of a Species object defined in the model.

        Returns 'True' if this Rule is a SpeciesConcentrationRule, 'False'
        otherwise.

        """
        return _libsbml.Rule_isSpeciesConcentration(self)


    def getTypeCode(self):
        """
        getTypeCode(Rule self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object, either
        SBML_ASSIGNMENT_RULE, SBML_RATE_RULE, or SBML_ALGEBRAIC_RULE  for SBML
        Core.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.Rule_getTypeCode(self)


    def getL1TypeCode(self):
        """
        getL1TypeCode(Rule self) -> int


        Returns the SBML Level 1 type code for this Rule object.

        This method only applies to SBML Level 1 model objects.  If this is
        not an SBML Level 1 rule object, this method will return SBML_UNKNOWN.

        Returns the SBML Level 1 type code for this Rule (namely,
        SBML_COMPARTMENT_VOLUME_RULE, SBML_PARAMETER_RULE,
        SBML_SPECIES_CONCENTRATION_RULE, or SBML_UNKNOWN).

        """
        return _libsbml.Rule_getL1TypeCode(self)


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


        Returns the XML element name of this object.

        The returned value can be any of a number of different strings,
        depending on the SBML Level in use and the kind of Rule object this
        is.  The rules as of libSBML version 5.18.0

        are the following:

        * (Level 2 and 3) RateRule: returns ''rateRule''

        * (Level 2 and 3) AssignmentRule: returns ''assignmentRule''

        * (Level 2 and 3) AlgebraicRule: returns ''algebraicRule''

        * (Level 1 Version 1) SpecieConcentrationRule: returns
        ''specieConcentrationRule''

        * (Level 1 Version 2) SpeciesConcentrationRule: returns
        ''speciesConcentrationRule''

        * (Level 1) CompartmentVolumeRule: returns
        ''compartmentVolumeRule''

        * (Level 1) ParameterRule: returns ''parameterRule''

        * Unknown rule type: returns ''unknownRule'' Beware that the last
        (''unknownRule')' is not a valid SBML element name.

        Returns the name of this element.

        """
        return _libsbml.Rule_getElementName(self)


    def setL1TypeCode(self, type):
        """
        setL1TypeCode(Rule self, int type) -> int


        Sets the SBML Level 1 type code for this Rule.

        Parameter 'type' is the SBML Level 1 type code for this Rule. The
        allowable values are SBML_COMPARTMENT_VOLUME_RULE,
        SBML_PARAMETER_RULE, and SBML_SPECIES_CONCENTRATION_RULE.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE if given 'type' value is not one
        of the above.

        """
        return _libsbml.Rule_setL1TypeCode(self, type)


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


        Predicate returning 'True' if all the required elements for this Rule
        object have been set.

        The only required element for a Rule object is the 'math' subelement
        in SBML Level 2 and Level 3 Version 1.  In SBML Level 3 Version 2+, it
        is no longer required.

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

        """
        return _libsbml.Rule_hasRequiredElements(self)


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


        Predicate returning 'True' if all the required attributes for this
        Rule object have been set.

        The required attributes for a Rule object depend on the type of Rule
        it is.  For AssignmentRule and RateRule objects (and SBML Level 1's
        SpeciesConcentrationRule, CompartmentVolumeRule, and ParameterRule
        objects), the required attribute is 'variable'; for AlgebraicRule
        objects, there is no required attribute.

        Returns 'True' if the required attributes have been set, 'False'
        otherwise.

        """
        return _libsbml.Rule_hasRequiredAttributes(self)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(Rule self, string oldid, string newid)


        Replaces all uses of a given 'SIdRef' type attribute value with
        another value.

        In SBML, object identifiers are of a data type called SId. In SBML
        Level 3, an explicit data type called SIdRef was introduced for
        attribute values that refer to SId values; in previous Levels of SBML,
        this data type did not exist and attributes were simply described to
        as 'referring to an identifier', but the effective data type was the
        same as SIdRef in Level 3.  These and other methods of libSBML refer
        to the type SIdRef for all Levels of SBML, even if the corresponding
        SBML specification did not explicitly name the data type.

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas in MathML content, comparing the referenced
        identifiers to the value of 'oldid'.  If any matches are found, the
        matching values are replaced with 'newid'.  The method does not
        descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.Rule_renameSIdRefs(self, oldid, newid)


    def renameUnitSIdRefs(self, oldid, newid):
        """
        renameUnitSIdRefs(Rule self, string oldid, string newid)


        Replaces all uses of a given 'UnitSIdRef' type attribute value with
        another value.

        In SBML, unit definitions have identifiers of type UnitSId.  In SBML
        Level 3, an explicit data type called UnitSIdRef was introduced for
        attribute values that refer to UnitSId values; in previous Levels of
        SBML, this data type did not exist and attributes were simply
        described to as 'referring to a unit identifier', but the effective
        data type was the same as UnitSIdRef in Level 3.  These and other
        methods of libSBML refer to the type UnitSIdRef for all Levels of
        SBML, even if the corresponding SBML specification did not explicitly
        name the data type.

        This method works by looking at all unit identifier attribute values
        (including, if appropriate, inside mathematical formulas), comparing
        the referenced unit identifiers to the value of 'oldid'.  If any
        matches are found, the matching values are replaced with 'newid'.  The
        method does not descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.Rule_renameUnitSIdRefs(self, oldid, newid)


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


        Returns the value of the 'variable' attribute of this Rule (NOT the
        'id').

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is now recommended to use the
        getIdAttribute() or the getVariable() function instead.

        The 'variable' attribute of a Rule indicates the element which the
        results of the 'math' are to be applied.  An AlgebraicRule has no
        'variable', and will always return an empty string.

        Returns the variable of this Rule.

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute(), getVariable().

        """
        return _libsbml.Rule_getId(self)


    def replaceSIDWithFunction(self, id, function):
        """
        replaceSIDWithFunction(Rule self, string id, ASTNode function)


        Internal implementation method.

        """
        return _libsbml.Rule_replaceSIDWithFunction(self, id, function)


    def divideAssignmentsToSIdByFunction(self, id, function):
        """
        divideAssignmentsToSIdByFunction(Rule self, string id, ASTNode function)


        Internal implementation method.

        """
        return _libsbml.Rule_divideAssignmentsToSIdByFunction(self, id, function)


    def multiplyAssignmentsToSIdByFunction(self, id, function):
        """
        multiplyAssignmentsToSIdByFunction(Rule self, string id, ASTNode function)


        Internal implementation method.

        """
        return _libsbml.Rule_multiplyAssignmentsToSIdByFunction(self, id, function)

Rule_swigregister = _libsbml.Rule_swigregister
Rule_swigregister(Rule)

class ListOfRules(ListOf):
    """

    A list of Rule objects.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfRules, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfRules, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ListOfRules self, unsigned int level, unsigned int version) -> ListOfRules
        __init__(ListOfRules self, SBMLNamespaces sbmlns) -> ListOfRules


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfRules(SBMLNamespaces sbmlns)

        Creates a new ListOfRules object.

        The object is constructed such that it is valid for the SBML Level and
        Version combination determined by the SBMLNamespaces object in
        'sbmlns'.

        Parameter 'sbmlns' is an SBMLNamespaces object that is used to
        determine the characteristics of the ListOfRules object to be created.

        Throws SBMLConstructorException: Thrown if the given 'sbmlns' is
        inconsistent or incompatible with this object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfRules(long level, long version)

        Creates a new ListOfRules object.

        The object is constructed such that it is valid for the given SBML
        Level and Version combination.

        Parameter 'level' is the SBML Level.

        Parameter 'version' is the Version within the SBML Level.

        Throws SBMLConstructorException: Thrown if the given 'level' and
        'version' combination are invalid or if this object is incompatible
        with the given level and version.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        """
        this = _libsbml.new_ListOfRules(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ListOfRules self) -> ListOfRules


        Creates and returns a deep copy of this ListOfRules object.

        Returns the (deep) copy of this ListOfRules object.

        """
        return _libsbml.ListOfRules_clone(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfRules self) -> int


        Returns the libSBML type code for the objects contained in this ListOf
        (i.e., Rule objects, if the list is non-empty).

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for objects contained in this list:
        SBML_RULE (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfRules_getItemTypeCode(self)


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


        Returns the XML element name of this object.

        For ListOfRules, the XML element name is ''listOfRules'.'

        Returns the name of this element, i.e., ''listOfRules'.'

        """
        return _libsbml.ListOfRules_getElementName(self)


    def get(self, *args):
        """
        get(ListOfRules self, unsigned int n) -> Rule
        get(ListOfRules self, unsigned int n) -> Rule
        get(ListOfRules self, string sid) -> Rule
        get(ListOfRules self, string sid) -> Rule


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a Rule from the ListOfRules.

        Parameter 'n' is the index number of the Rule to get.

        Returns the nth Rule in this ListOfRules. If the index 'n' is invalid,
        'None' is returned.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a Rule from the ListOfRules based on its identifier.

        Parameter 'sid' is a string representing the identifier of the Rule to
        get.

        Returns Rule in this ListOfRules with the given 'sid' or 'None' if no
        such Rule exists.

        See also get(), size().

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


    def getElementBySId(self, id):
        """
        getElementBySId(ListOfRules self, string id) -> SBase


        Returns the first child element found that has the given 'id' in the
        model-wide SId namespace, or 'None' if no such object is found.

        Note that AssignmentRules and RateRules do not actually have IDs, but
        the libsbml interface pretends that they do: no assignment rule or
        rate rule is returned by this function.

        Parameter 'id' is string representing the id of the object to find.

        Returns pointer to the first element found with the given 'id'.

        """
        return _libsbml.ListOfRules_getElementBySId(self, id)


    def remove(self, *args):
        """
        remove(ListOfRules self, unsigned int n) -> Rule
        remove(ListOfRules self, string sid) -> Rule


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth item from this ListOfRules items and returns a pointer
        to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the item to remove.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes item in this ListOfRules 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 'sid', then
        'None' is returned.

        Parameter 'sid' is the identifier of the item to remove.

        Returns the item removed.  As mentioned above, the caller owns the
        returned item.

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

    __swig_destroy__ = _libsbml.delete_ListOfRules
    __del__ = lambda self: None
ListOfRules_swigregister = _libsbml.ListOfRules_swigregister
ListOfRules_swigregister(ListOfRules)

class AlgebraicRule(Rule):
    """

    An SBML algebraic rule representing 0 = f(W).

    The rule type AlgebraicRule is derived from the parent class Rule.  It
    is used to express equations that are neither assignments of model
    variables nor rates of change.  AlgebraicRule does not add any
    attributes to the basic Rule; its role is simply to distinguish this
    case from the other cases.

    In the context of a simulation, algebraic rules are in effect at all
    times, t >= 0.  For purposes of evaluating expressions that involve
    the delay 'csymbol' (see the SBML specification), algebraic rules are
    considered to apply also at t <= 0.  Please consult the relevant SBML
    specification for additional information about the semantics of
    assignments, rules, and entity values for simulation time t <= 0.

    An SBML model must not be overdetermined.  The ability to define
    arbitrary algebraic expressions in an SBML model introduces the
    possibility that a model is mathematically overdetermined by the
    overall system of equations constructed from its rules, reactions and
    events. Therefore, if an algebraic rule is introduced in a model, for
    at least one of the entities referenced in the rule's 'math' element
    the value of that entity must not be completely determined by other
    constructs in the model.  This means that at least this entity must
    not have the attribute 'constant'='True' and there must also not be a
    rate rule or assignment rule for it.  Furthermore, if the entity is a
    Species object, its value must not be determined by reactions, which
    means that it must either have the attribute
    'boundaryCondition'='True' or else not be involved in any reaction at
    all.  These restrictions are explained in more detail in the SBML
    specification documents.

    In SBML Levels 2 and 3, Reaction object identifiers can be referenced
    in the 'math' expression of an algebraic rule, but reaction rates can
    never be determined by algebraic rules.  This is true even when a
    reaction does not contain a KineticLaw object.  (In such cases of
    missing kinetic law definitions, the model is valid but incomplete;
    the rates of reactions lacking kinetic laws are simply undefined, and
    not determined by the algebraic rule.)

    In SBML Level 2 and Level 3 Version 1, the 'math' subelement of the
    AlgebraicRule is required.  In SBML Level 3 Version 2, this rule is
    relaxed, and the subelement is optional.  If an AlgebraicRule with no
    'math' child is present in the model, no additional mathematical
    constraints on the model are added by the rule.  This may represent a
    situation where the model itself is unfinished, or the missing
    information may be provided by an SBML Level 3 package.

    Finally, any symbol that appears as the target of a rateOf csymbol
    (AST_FUNCTION_RATE_OF, introduced in  SBML Level 3 Version 2) may  not
    be determined by an AlgebraicRule. This is because the rateOf  csymbol
    is defined as applying only to symbols whose rates of change  are
    easily determinable.

    Users should note that these rules about what symbols may not be
    determined by an AlgebraicRule may be used to discover what symbol  is
    being determined by an AlgebraicRule. If three symbols appear in  the
    math element of an AlgebraicRule, the first of which is flagged
    constant='True,' and the second of which appears as the target of a
    rateOf csymbol, one may conclude that the AlgebraicRule must be used
    to determine the value of the third symbol. This is, in fact, a
    principle use (outside of validation) of the constant attribute: its
    use in allowing software to properly identify the dependent variable
    in an AlgebraicRule.

    General summary of SBML rules
    ======================================================================

    In SBML Level 3 as well as Level 2, rules are separated into three
    subclasses for the benefit of model analysis software.  The three
    subclasses are based on the following three different possible
    functional forms (where x is a variable, f is some arbitrary function
    returning a numerical result, V is a vector of variables that does not
    include x, and W is a vector of variables that may include x):

       Algebraic:   left-hand side is zero               0 = f(W)     
       Assignment:  left-hand side is a scalar:          x = f(V)     
       Rate:        left-hand side is a rate-of-change:  dx/dt = f(W)

    In their general form given above, there is little to distinguish
    between assignment and algebraic rules.  They are treated as separate
    cases for the following reasons:

    * Assignment rules can simply be evaluated to calculate
    intermediate values for use in numerical methods.  They are statements
    of equality that hold at all times.  (For assignments that are only
    performed once, see InitialAssignment.)

    * SBML needs to place restrictions on assignment rules, for example
    the restriction that assignment rules cannot contain algebraic loops.

    * Some simulators do not contain numerical solvers capable of
    solving unconstrained algebraic equations, and providing more direct
    forms such as assignment rules may enable those simulators to process
    models they could not process if the same assignments were put in the
    form of general algebraic equations;

    * Those simulators that can solve these algebraic equations make a
    distinction between the different categories listed above; and

    * Some specialized numerical analyses of models may only be
    applicable to models that do not contain algebraic rules.

    The approach taken to covering these cases in SBML is to define an
    abstract Rule structure containing a subelement, 'math', to hold the
    right-hand side expression, then to derive subtypes of Rule that add
    attributes to distinguish the cases of algebraic, assignment and rate
    rules.  The 'math' subelement must contain a MathML expression
    defining the mathematical formula of the rule.  This MathML formula
    must return a numerical value.  The formula can be an arbitrary
    expression referencing the variables and other entities in an SBML
    model.

    Each of the three subclasses of Rule (AssignmentRule, AlgebraicRule,
    RateRule) inherit the the 'math' subelement and other fields from
    SBase. The AssignmentRule and RateRule classes add an additional
    attribute, 'variable'.  See the definitions of AssignmentRule,
    AlgebraicRule and RateRule for details about the structure and
    interpretation of each one.

    Additional restrictions on SBML rules
    ======================================================================

    An important design goal of SBML rule semantics is to ensure that a
    model's simulation and analysis results will not be dependent on when
    or how often rules are evaluated.  To achieve this, SBML needs to
    place two restrictions on rule use.  The first concerns algebraic
    loops in the system of assignments in a model, and the second concerns
    overdetermined systems.

    A model must not contain algebraic loops
    ......................................................................

    The combined set of InitialAssignment, AssignmentRule and KineticLaw
    objects in a model constitute a set of assignment statements that
    should be considered as a whole.  (A KineticLaw object is counted as
    an assignment because it assigns a value to the symbol contained in
    the 'id' attribute of the Reaction object in which it is defined.)
    This combined set of assignment statements must not contain algebraic
    loops---dependency chains between these statements must terminate.  To
    put this more formally, consider a directed graph in which nodes are
    assignment statements and directed arcs exist for each occurrence of
    an SBML species, compartment or parameter symbol in an assignment
    statement's 'math' subelement.  Let the directed arcs point from the
    statement assigning the symbol to the statements that contain the
    symbol in their 'math' subelement expressions. This graph must be
    acyclic.

    Similarly, the combined set of RateRule and Reaction objects
    constitute  a set of definitions for the rates of change of various
    model entities  (namely, the objects identified by the values of the
    'variable' attributes  of the RateRule objects, and the 'species'
    attributes of the SpeciesReference  objects in each Reaction).  In
    SBML Level 3 Version 2, these rates  of change may be referenced
    directly  using the rateOf csymbol, but may not thereby contain
    algebraic  loops---dependency chains between these statements must
    terminate.  More  formally, consider a directed graph in which the
    nodes are the definitions  of different variables' rates of change,
    and directed arcs exist for each  occurrence of a variable referenced
    by a rateOf csymbol from any  RateRule or KineticLaw object in the
    model.  Let the directed arcs point  from the variable referenced by
    the rateOf csymbol (call it  x) to the variable(s) determined by the
    'math' expression in which x appears.  This graph must be acyclic.

    SBML does not specify when or how often rules should be evaluated.
    Eliminating algebraic loops ensures that assignment statements can be
    evaluated any number of times without the result of those evaluations
    changing.  As an example, consider the set of equations x = x + 1, y =
    z + 200 and z = y + 100.  If this set of equations were interpreted as
    a set of assignment statements, it would be invalid because the rule
    for x refers to x (exhibiting one type of loop), and the rule for y
    refers to z while the rule for z refers back to y (exhibiting another
    type of loop). Conversely, the following set of equations would
    constitute a valid set of assignment statements: x = 10, y = z + 200,
    and z = x + 100.

    A model must not be overdetermined
    ......................................................................

    An SBML model must not be overdetermined; that is, a model must not
    define more equations than there are unknowns in a model.  A valid
    SBML model that does not contain AlgebraicRule structures cannot be
    overdetermined.

    LibSBML implements the static analysis procedure described in Appendix
    B of the SBML Level 3 specification for assessing whether a model is
    overdetermined.

    (In summary, assessing whether a given continuous, deterministic,
    mathematical model is overdetermined does not require dynamic
    analysis; it can be done by analyzing the system of equations created
    from the model. One approach is to construct a bipartite graph in
    which one set of vertices represents the variables and the other the
    set of vertices represents the equations.  Place edges between
    vertices such that variables in the system are linked to the equations
    that determine them.  For algebraic equations, there will be edges
    between the equation and each variable occurring in the equation.  For
    ordinary differential equations (such as those defined by rate rules
    or implied by the reaction rate definitions), there will be a single
    edge between the equation and the variable determined by that
    differential equation.  A mathematical model is overdetermined if the
    maximal matchings of the bipartite graph contain disconnected vertexes
    representing equations.  If one maximal matching has this property,
    then all the maximal matchings will have this property; i.e., it is
    only necessary to find one maximal matching.)

    Rule types for SBML Level 1
    ======================================================================

    SBML Level 1 uses a different scheme than SBML Level 2 and Level 3 for
    distinguishing rules; specifically, it uses an attribute whose value
    is drawn from an enumeration of 3 values.  LibSBML supports this using
    methods that work with the enumeration values  listed below.

    * RULE_TYPE_RATE: Indicates the rule is a 'rate' rule.

    * RULE_TYPE_SCALAR: Indicates the rule is a 'scalar' rule.

    * RULE_TYPE_INVALID: Indicates the rule type is unknown or not yet
    set.

    """

    __swig_setmethods__ = {}
    for _s in [Rule]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AlgebraicRule, name, value)
    __swig_getmethods__ = {}
    for _s in [Rule]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, AlgebraicRule, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(AlgebraicRule self, unsigned int level, unsigned int version) -> AlgebraicRule
        __init__(AlgebraicRule self, SBMLNamespaces sbmlns) -> AlgebraicRule


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            AlgebraicRule(SBMLNamespaces sbmlns)

        Creates a new AlgebraicRule object using the given SBMLNamespaces
        object 'sbmlns'.

        The SBMLNamespaces object encapsulates SBML Level/Version/namespaces
        information.  It is used to communicate the SBML Level, Version, and
        (in Level 3) packages used in addition to SBML Level 3 Core.  A common
        approach to using libSBML's SBMLNamespaces facilities is to create an
        SBMLNamespaces object somewhere in a program once, then hand that
        object as needed to object constructors that accept SBMLNamespaces as
        arguments.

        Parameter 'sbmlns' is an SBMLNamespaces object.

        Throws SBMLConstructorException: Thrown if the given 'sbmlns' is
        inconsistent or incompatible with this object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            AlgebraicRule(long level, long version)

        Creates a new AlgebraicRule object using the given SBML 'level' and
        'version' values.

        Parameter 'level' is the SBML Level to assign to this AlgebraicRule
        object.

        Parameter 'version' is the SBML Version to assign to this
        AlgebraicRule object.

        Throws SBMLConstructorException: Thrown if the given 'level' and
        'version' combination are invalid or if this object is incompatible
        with the given level and version.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        """
        this = _libsbml.new_AlgebraicRule(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_AlgebraicRule
    __del__ = lambda self: None

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


        Creates and returns a deep copy of this AlgebraicRule object.

        Returns the (deep) copy of this Rule object.

        """
        return _libsbml.AlgebraicRule_clone(self)


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


        Predicate returning 'True' if all the required attributes for this
        AlgebraicRule object have been set.

        In SBML Levels 2-3, there is no required attribute for an
        AlgebraicRule object.  For Level 1, the only required attribute is
        'formula'.

        Returns 'True' if the required attributes have been set, 'False'
        otherwise.

        """
        return _libsbml.AlgebraicRule_hasRequiredAttributes(self)

AlgebraicRule_swigregister = _libsbml.AlgebraicRule_swigregister
AlgebraicRule_swigregister(AlgebraicRule)

class AssignmentRule(Rule):
    """

    An SBML assignment rule representing x = f(Y).

    The rule type AssignmentRule is derived from the parent class Rule.
    It is used to express equations that set the values of variables.  The
    left-hand side (the attribute named 'variable') of an assignment rule
    must refer to the identifier of a Species, SpeciesReference (in SBML
    Level 3), Compartment, or global Parameter object in the model (but
    not a Reaction).  In SBML Level 3 Version 2, it may also refer to the
    SId of an element defined in an SBML Level 3 package with
    mathematical meaning and the ability to be assigned. The entity
    identified must have its 'constant' attribute set to 'False.'  The
    effects of an assignment rule construct are in general terms the same,
    but differ in the precise details depending on the type of SBML
    component being set:

    * In the case of a species, an SBML assignment rule sets the
    referenced species' quantity (whether a 'concentration' or 'amount')
    to the value determined by the formula in the MathML subelement
    'math'. The unit associated with the value produced by the 'math'
    formula should (in SBML Level 2 Version 4 and in SBML Level 3) or must
    (in SBML releases prior to Level 2 version 4) be equal to the unit
    associated with the species' quantity.  Restrictions: There must not
    be both an AssignmentRule 'variable' attribute and a SpeciesReference
    'species' attribute having the same value in a model, unless the
    referenced Species object has its 'boundaryCondition' attribute set to
    'True.'  In other words, an assignment rule cannot be defined for a
    species that is created or destroyed in a reaction unless that species
    is defined as a boundary condition in the model.

    * (For SBML Level 3 only) In the case of a species reference, an
    assignment rule sets the stoichiometry of the referenced reactant or
    product to the value determined by the formula in 'math'.  The unit
    associated with the value produced by the 'math' formula should be
    consistent with the unit 'dimensionless', because reactant and product
    stoichiometries in reactions are dimensionless quantities.

    * In the case of a compartment, an SBML assignment rule sets the
    referenced compartment's size to the value determined by the formula
    in the 'math' subelement of the AssignmentRule object.  The overall
    units of the formula in 'math' should (in SBML Level 2 Version 4 and
    in SBML Level 3) or must (in SBML releases prior to Level 2 version 4)
    be the same as the units of the size of the compartment.

    * In the case of a parameter, an assignment rule sets the referenced
    parameter's value to that determined by the formula in the 'math'
    subelement of the AssignmentRule object.  The overall units of the
    formula in the 'math' subelement should (in SBML Level 2 Version 4 and
    in SBML Level 3) or must (in SBML releases prior to Level 2 version 4)
    be the same as the units defined for the parameter.

    * (For SBML Level 3 Version 2 only) In the case of  an object from an
    SBML Level 3 package, an AssignmentRule sets  the referenced object's
    value (as defined by that package) to the  value of the formula in
    math. The unit of measurement associated  with the value produced by
    the formula should be the same as that  object's units attribute value
    (if it has such an attribute), or be  equal to the units of model
    components of that type (if objects of  that class are defined by the
    package as having the same units).

    In SBML Level 2 and Level 3 Version 1, the 'math'  subelement of the
    AssignmentRule is required.  In SBML Level 3 Version 2, this rule is
    relaxed, and the subelement is optional.  If an AssignmentRule with no
    'math' child is present in the model, the value of its referenced
    'variable' is  undefined.  This may represent a situation where the
    model itself is unfinished, or the missing information may be provided
    by an SBML Level 3 package.

    If the variable attribute of an AssignmentRule object references an
    object in an SBML namespace not understood by the interpreter reading
    a given SBML document (that is, if the object is defined by an SBML
    Level 3 package that the software does not support), the assignment
    rule must be ignored--the object's value will not need to be set, as
    the  interpreter could not understand that package. If an interpreter
    cannot  establish whether a referenced object is missing from the
    model or  instead is defined in an SBML namespace not understood by
    the interpreter,  it may produce a warning to the user. (The latter
    situation may only  arise if an SBML package is present in the SBML
    document with a  package:required attribute of 'true'.)

    In the context of a simulation, assignment rules are in effect at all
    times, t >= 0.  For purposes of evaluating expressions that involve
    the delay 'csymbol' (see the SBML Level 2 specification), assignment
    rules are considered to apply also at t <= 0.  Please consult the
    relevant SBML specification for additional information about the
    semantics of assignments, rules, and entity values for simulation time
    t <= 0.

    A model must not contain more than one AssignmentRule or RateRule
    object having the same value of 'variable'; in other words, in the set
    of all assignment rules and rate rules in an SBML model, each variable
    appearing in the left-hand sides can only appear once.  This simply
    follows from the fact that an indeterminate system would result if a
    model contained more than one assignment rule for the same variable or
    both an assignment rule and a rate rule for the same variable.

    Similarly, a model must also not contain both an AssignmentRule and an
    InitialAssignment definition for the same variable, because both kinds
    of constructs apply prior to and at the start of simulation time,
    i.e., t <= 0.  If a model contained both an initial assignment and an
    assignment rule for the same variable, an indeterminate system would
    result.

    The value calculated by an AssignmentRule object overrides the value
    assigned to the given symbol by the model component defining that
    symbol.  For example, if a Compartment object's 'size' attribute value
    is set in its definition, and the model also contains an
    AssignmentRule object  having that compartment's 'id' as its
    'variable' value, then the 'size' assigned in the Compartment object
    definition is ignored and the value assigned based on the computation
    defined in the AssignmentRule.  This does not mean that a definition
    for a given symbol can be omitted if there is an AssignmentRule object
    involving it.  For example,  there must be a Parameter object
    definition for a given parameter if there is an AssignmentRule
    definition for that parameter.  It is only a question of which value
    definition takes precedence.

    General summary of SBML rules
    ======================================================================

    In SBML Level 3 as well as Level 2, rules are separated into three
    subclasses for the benefit of model analysis software.  The three
    subclasses are based on the following three different possible
    functional forms (where x is a variable, f is some arbitrary function
    returning a numerical result, V is a vector of variables that does not
    include x, and W is a vector of variables that may include x):

       Algebraic:   left-hand side is zero               0 = f(W)     
       Assignment:  left-hand side is a scalar:          x = f(V)     
       Rate:        left-hand side is a rate-of-change:  dx/dt = f(W)

    In their general form given above, there is little to distinguish
    between assignment and algebraic rules.  They are treated as separate
    cases for the following reasons:

    * Assignment rules can simply be evaluated to calculate
    intermediate values for use in numerical methods.  They are statements
    of equality that hold at all times.  (For assignments that are only
    performed once, see InitialAssignment.)

    * SBML needs to place restrictions on assignment rules, for example
    the restriction that assignment rules cannot contain algebraic loops.

    * Some simulators do not contain numerical solvers capable of
    solving unconstrained algebraic equations, and providing more direct
    forms such as assignment rules may enable those simulators to process
    models they could not process if the same assignments were put in the
    form of general algebraic equations;

    * Those simulators that can solve these algebraic equations make a
    distinction between the different categories listed above; and

    * Some specialized numerical analyses of models may only be
    applicable to models that do not contain algebraic rules.

    The approach taken to covering these cases in SBML is to define an
    abstract Rule structure containing a subelement, 'math', to hold the
    right-hand side expression, then to derive subtypes of Rule that add
    attributes to distinguish the cases of algebraic, assignment and rate
    rules.  The 'math' subelement must contain a MathML expression
    defining the mathematical formula of the rule.  This MathML formula
    must return a numerical value.  The formula can be an arbitrary
    expression referencing the variables and other entities in an SBML
    model.

    Each of the three subclasses of Rule (AssignmentRule, AlgebraicRule,
    RateRule) inherit the the 'math' subelement and other fields from
    SBase. The AssignmentRule and RateRule classes add an additional
    attribute, 'variable'.  See the definitions of AssignmentRule,
    AlgebraicRule and RateRule for details about the structure and
    interpretation of each one.

    Additional restrictions on SBML rules
    ======================================================================

    An important design goal of SBML rule semantics is to ensure that a
    model's simulation and analysis results will not be dependent on when
    or how often rules are evaluated.  To achieve this, SBML needs to
    place two restrictions on rule use.  The first concerns algebraic
    loops in the system of assignments in a model, and the second concerns
    overdetermined systems.

    A model must not contain algebraic loops
    ......................................................................

    The combined set of InitialAssignment, AssignmentRule and KineticLaw
    objects in a model constitute a set of assignment statements that
    should be considered as a whole.  (A KineticLaw object is counted as
    an assignment because it assigns a value to the symbol contained in
    the 'id' attribute of the Reaction object in which it is defined.)
    This combined set of assignment statements must not contain algebraic
    loops---dependency chains between these statements must terminate.  To
    put this more formally, consider a directed graph in which nodes are
    assignment statements and directed arcs exist for each occurrence of
    an SBML species, compartment or parameter symbol in an assignment
    statement's 'math' subelement.  Let the directed arcs point from the
    statement assigning the symbol to the statements that contain the
    symbol in their 'math' subelement expressions. This graph must be
    acyclic.

    Similarly, the combined set of RateRule and Reaction objects
    constitute  a set of definitions for the rates of change of various
    model entities  (namely, the objects identified by the values of the
    'variable' attributes  of the RateRule objects, and the 'species'
    attributes of the SpeciesReference  objects in each Reaction).  In
    SBML Level 3 Version 2, these rates  of change may be referenced
    directly  using the rateOf csymbol, but may not thereby contain
    algebraic  loops---dependency chains between these statements must
    terminate.  More  formally, consider a directed graph in which the
    nodes are the definitions  of different variables' rates of change,
    and directed arcs exist for each  occurrence of a variable referenced
    by a rateOf csymbol from any  RateRule or KineticLaw object in the
    model.  Let the directed arcs point  from the variable referenced by
    the rateOf csymbol (call it  x) to the variable(s) determined by the
    'math' expression in which x appears.  This graph must be acyclic.

    SBML does not specify when or how often rules should be evaluated.
    Eliminating algebraic loops ensures that assignment statements can be
    evaluated any number of times without the result of those evaluations
    changing.  As an example, consider the set of equations x = x + 1, y =
    z + 200 and z = y + 100.  If this set of equations were interpreted as
    a set of assignment statements, it would be invalid because the rule
    for x refers to x (exhibiting one type of loop), and the rule for y
    refers to z while the rule for z refers back to y (exhibiting another
    type of loop). Conversely, the following set of equations would
    constitute a valid set of assignment statements: x = 10, y = z + 200,
    and z = x + 100.

    A model must not be overdetermined
    ......................................................................

    An SBML model must not be overdetermined; that is, a model must not
    define more equations than there are unknowns in a model.  A valid
    SBML model that does not contain AlgebraicRule structures cannot be
    overdetermined.

    LibSBML implements the static analysis procedure described in Appendix
    B of the SBML Level 3 specification for assessing whether a model is
    overdetermined.

    (In summary, assessing whether a given continuous, deterministic,
    mathematical model is overdetermined does not require dynamic
    analysis; it can be done by analyzing the system of equations created
    from the model. One approach is to construct a bipartite graph in
    which one set of vertices represents the variables and the other the
    set of vertices represents the equations.  Place edges between
    vertices such that variables in the system are linked to the equations
    that determine them.  For algebraic equations, there will be edges
    between the equation and each variable occurring in the equation.  For
    ordinary differential equations (such as those defined by rate rules
    or implied by the reaction rate definitions), there will be a single
    edge between the equation and the variable determined by that
    differential equation.  A mathematical model is overdetermined if the
    maximal matchings of the bipartite graph contain disconnected vertexes
    representing equations.  If one maximal matching has this property,
    then all the maximal matchings will have this property; i.e., it is
    only necessary to find one maximal matching.)

    Rule types for SBML Level 1
    ======================================================================

    SBML Level 1 uses a different scheme than SBML Level 2 and Level 3 for
    distinguishing rules; specifically, it uses an attribute whose value
    is drawn from an enumeration of 3 values.  LibSBML supports this using
    methods that work with the enumeration values  listed below.

    * RULE_TYPE_RATE: Indicates the rule is a 'rate' rule.

    * RULE_TYPE_SCALAR: Indicates the rule is a 'scalar' rule.

    * RULE_TYPE_INVALID: Indicates the rule type is unknown or not yet
    set.

    """

    __swig_setmethods__ = {}
    for _s in [Rule]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AssignmentRule, name, value)
    __swig_getmethods__ = {}
    for _s in [Rule]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, AssignmentRule, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(AssignmentRule self, unsigned int level, unsigned int version) -> AssignmentRule
        __init__(AssignmentRule self, SBMLNamespaces sbmlns) -> AssignmentRule


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            AssignmentRule(SBMLNamespaces sbmlns)

        Creates a new AssignmentRule using the given SBMLNamespaces object
        'sbmlns'.

        The SBMLNamespaces object encapsulates SBML Level/Version/namespaces
        information.  It is used to communicate the SBML Level, Version, and
        (in Level 3) packages used in addition to SBML Level 3 Core.  A common
        approach to using libSBML's SBMLNamespaces facilities is to create an
        SBMLNamespaces object somewhere in a program once, then hand that
        object as needed to object constructors that accept SBMLNamespaces as
        arguments.

        Parameter 'sbmlns' is an SBMLNamespaces object.

        Throws SBMLConstructorException: Thrown if the given 'sbmlns' is
        inconsistent or incompatible with this object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            AssignmentRule(long level, long version)

        Creates a new AssignmentRule using the given SBML 'level' and
        'version' values.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        AssignmentRule.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this AssignmentRule.

        Throws SBMLConstructorException: Thrown if the given 'level' and
        'version' combination are invalid or if this object is incompatible
        with the given level and version.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        """
        this = _libsbml.new_AssignmentRule(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_AssignmentRule
    __del__ = lambda self: None

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


        Creates and returns a deep copy of this AssignmentRule object.

        Returns the (deep) copy of this Rule object.

        """
        return _libsbml.AssignmentRule_clone(self)


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


        Predicate returning 'True' if all the required attributes for this
        AssignmentRule object have been set.

        In SBML Levels 2-3, the only required attribute for an AssignmentRule
        object is 'variable'.  For Level 1, where the equivalent attribute is
        known by different names ('compartment', 'species', or 'name',
        depending on the type of object), there is an additional required
        attribute called 'formula'.

        Returns 'True' if the required attributes have been set, 'False'
        otherwise.

        """
        return _libsbml.AssignmentRule_hasRequiredAttributes(self)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(AssignmentRule self, string oldid, string newid)


        Replaces all uses of a given 'SIdRef' type attribute value with
        another value.

        In SBML, object identifiers are of a data type called SId. In SBML
        Level 3, an explicit data type called SIdRef was introduced for
        attribute values that refer to SId values; in previous Levels of SBML,
        this data type did not exist and attributes were simply described to
        as 'referring to an identifier', but the effective data type was the
        same as SIdRef in Level 3.  These and other methods of libSBML refer
        to the type SIdRef for all Levels of SBML, even if the corresponding
        SBML specification did not explicitly name the data type.

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas in MathML content, comparing the referenced
        identifiers to the value of 'oldid'.  If any matches are found, the
        matching values are replaced with 'newid'.  The method does not
        descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.AssignmentRule_renameSIdRefs(self, oldid, newid)

AssignmentRule_swigregister = _libsbml.AssignmentRule_swigregister
AssignmentRule_swigregister(AssignmentRule)

class RateRule(Rule):
    """

    An SBML rate rule representing dx/dt = f(Y).

    The rule type RateRule is derived from the parent class Rule.  It is
    used to express equations that determine the rates of change of
    variables.  The left-hand side (the 'variable' attribute) can refer to
    the identifier of a species, compartment, or parameter (but not a
    reaction).  The entity identified must have its 'constant' attribute
    set to 'False.'  The effects of a RateRule are in general terms the
    same, but differ in the precise details depending on which variable is
    being set:

    * In the case of a species, a RateRule sets the rate of change of
    the species' quantity (concentration or amount of substance) to the
    value determined by the formula in the 'math' subelement of the
    RateRule object.  The overall units of the formula in 'math' should
    (in SBML Level 2 Version 4 and in SBML Level 3) or must (in SBML
    releases prior to Level 2 version 4) be equal to the unit of species
    quantity divided by the model-wide unit of time.  Restrictions: There
    must not be both a RateRule 'variable' attribute and a
    SpeciesReference 'species' attribute having the same value, unless
    that species has its 'boundaryCondition' attribute is set to 'True.'
    This means a rate rule cannot be defined for a species that is created
    or destroyed in a reaction, unless that species is defined as a
    boundary condition in the model.

    * (For SBML Level 3 only) In the case of a species reference, a
    RateRule sets the rate of change of the stoichiometry of the
    referenced reactant or product to the value determined by the formula
    in 'math'.  The unit associated with the value produced by the 'math'
    formula should be consistent with the unit 'dimensionless' divided by
    the model-wide unit of time.

    * In the case of a compartment, a RateRule sets the rate of change of
    the compartment's size to the value determined by the formula in the
    'math' subelement of the RateRule object.  The overall units of the
    formula should (in SBML Level 2 Version 4 and in SBML Level 3) or must
    (in SBML releases prior to Level 2 version 4) be the units of the
    compartment's size divided by the model-wide unit of time.

    * In the case of a parameter, a RateRule sets the rate of change of
    the parameter's value to that determined by the formula in the 'math'
    subelement of the RateRule object.  The overall units of the formula
    should (in SBML Level 2 Version 4 and in SBML Level 3) or must (in
    SBML releases prior to Level 2 version 4) be the Parameter object's
    'unit' attribute value divided by the model-wide unit of time.

    * (For SBML Level 3 Version 2 only) In the case of  an object from an
    SBML Level 3 package, a RateRule sets the rate  of change of the
    referenced object's value (as defined by that package)  to the value
    of the formula in 'math'.  The unit of measurement associated  with
    the value produced by the formula should be the same as that object's
    units attribute value (if it has such an attribute) divided by the
    model-wide unit of time, or be equal to the units of model components
    of that type (if objects of that class are defined by the package as
    having  the same units) divided by the model-wide unit of time. In
    SBML Level 2 and Level 3 Version 1, the 'math'  subelement of the
    RateRule is required.  In SBML Level 3 Version 2, this rule is
    relaxed, and the subelement is optional.  If a RateRule with no 'math'
    child is present in the model,  the rate at which its referenced
    'variable' changes over time is  undefined.  This may represent a
    situation where the model itself is unfinished, or the missing
    information may be provided by an SBML Level 3 package.

    If the variable attribute of a RateRule object references an object in
    an SBML namespace that is not understood by the interpreter reading a
    given SBML document (that is, if the object is defined by an SBML
    Level 3 package that the software does not support), the rate rule
    must be ignored--the object's value will not need to be set, as the
    interpreter could not understand that package. If an interpreter
    cannot  establish whether a referenced object is missing from the
    model or  instead is defined in an SBML namespace not understood by
    the interpreter,  it may produce a warning to the user. (The latter
    situation may only  arise if an SBML package is present in the SBML
    document with a  package:required attribute of 'true'.)

    In the context of a simulation, rate rules are in effect for
    simulation time t > 0.  Please consult the relevant SBML specification
    for additional information about the semantics of assignments, rules,
    and entity values for simulation time t <= 0.

    As mentioned in the description of AssignmentRule, a model must not
    contain more than one RateRule or AssignmentRule object having the
    same value of 'variable'; in other words, in the set of all assignment
    rules and rate rules in an SBML model, each variable appearing in the
    left-hand sides can only appear once.  This simply follows from the
    fact that an indeterminate system would result if a model contained
    more than one assignment rule for the same variable or both an
    assignment rule and a rate rule for the same variable.

    General summary of SBML rules
    ======================================================================

    In SBML Level 3 as well as Level 2, rules are separated into three
    subclasses for the benefit of model analysis software.  The three
    subclasses are based on the following three different possible
    functional forms (where x is a variable, f is some arbitrary function
    returning a numerical result, V is a vector of variables that does not
    include x, and W is a vector of variables that may include x):

       Algebraic:   left-hand side is zero               0 = f(W)     
       Assignment:  left-hand side is a scalar:          x = f(V)     
       Rate:        left-hand side is a rate-of-change:  dx/dt = f(W)

    In their general form given above, there is little to distinguish
    between assignment and algebraic rules.  They are treated as separate
    cases for the following reasons:

    * Assignment rules can simply be evaluated to calculate
    intermediate values for use in numerical methods.  They are statements
    of equality that hold at all times.  (For assignments that are only
    performed once, see InitialAssignment.)

    * SBML needs to place restrictions on assignment rules, for example
    the restriction that assignment rules cannot contain algebraic loops.

    * Some simulators do not contain numerical solvers capable of
    solving unconstrained algebraic equations, and providing more direct
    forms such as assignment rules may enable those simulators to process
    models they could not process if the same assignments were put in the
    form of general algebraic equations;

    * Those simulators that can solve these algebraic equations make a
    distinction between the different categories listed above; and

    * Some specialized numerical analyses of models may only be
    applicable to models that do not contain algebraic rules.

    The approach taken to covering these cases in SBML is to define an
    abstract Rule structure containing a subelement, 'math', to hold the
    right-hand side expression, then to derive subtypes of Rule that add
    attributes to distinguish the cases of algebraic, assignment and rate
    rules.  The 'math' subelement must contain a MathML expression
    defining the mathematical formula of the rule.  This MathML formula
    must return a numerical value.  The formula can be an arbitrary
    expression referencing the variables and other entities in an SBML
    model.

    Each of the three subclasses of Rule (AssignmentRule, AlgebraicRule,
    RateRule) inherit the the 'math' subelement and other fields from
    SBase. The AssignmentRule and RateRule classes add an additional
    attribute, 'variable'.  See the definitions of AssignmentRule,
    AlgebraicRule and RateRule for details about the structure and
    interpretation of each one.

    Additional restrictions on SBML rules
    ======================================================================

    An important design goal of SBML rule semantics is to ensure that a
    model's simulation and analysis results will not be dependent on when
    or how often rules are evaluated.  To achieve this, SBML needs to
    place two restrictions on rule use.  The first concerns algebraic
    loops in the system of assignments in a model, and the second concerns
    overdetermined systems.

    A model must not contain algebraic loops
    ......................................................................

    The combined set of InitialAssignment, AssignmentRule and KineticLaw
    objects in a model constitute a set of assignment statements that
    should be considered as a whole.  (A KineticLaw object is counted as
    an assignment because it assigns a value to the symbol contained in
    the 'id' attribute of the Reaction object in which it is defined.)
    This combined set of assignment statements must not contain algebraic
    loops---dependency chains between these statements must terminate.  To
    put this more formally, consider a directed graph in which nodes are
    assignment statements and directed arcs exist for each occurrence of
    an SBML species, compartment or parameter symbol in an assignment
    statement's 'math' subelement.  Let the directed arcs point from the
    statement assigning the symbol to the statements that contain the
    symbol in their 'math' subelement expressions. This graph must be
    acyclic.

    Similarly, the combined set of RateRule and Reaction objects
    constitute  a set of definitions for the rates of change of various
    model entities  (namely, the objects identified by the values of the
    'variable' attributes  of the RateRule objects, and the 'species'
    attributes of the SpeciesReference  objects in each Reaction).  In
    SBML Level 3 Version 2, these rates  of change may be referenced
    directly  using the rateOf csymbol, but may not thereby contain
    algebraic  loops---dependency chains between these statements must
    terminate.  More  formally, consider a directed graph in which the
    nodes are the definitions  of different variables' rates of change,
    and directed arcs exist for each  occurrence of a variable referenced
    by a rateOf csymbol from any  RateRule or KineticLaw object in the
    model.  Let the directed arcs point  from the variable referenced by
    the rateOf csymbol (call it  x) to the variable(s) determined by the
    'math' expression in which x appears.  This graph must be acyclic.

    SBML does not specify when or how often rules should be evaluated.
    Eliminating algebraic loops ensures that assignment statements can be
    evaluated any number of times without the result of those evaluations
    changing.  As an example, consider the set of equations x = x + 1, y =
    z + 200 and z = y + 100.  If this set of equations were interpreted as
    a set of assignment statements, it would be invalid because the rule
    for x refers to x (exhibiting one type of loop), and the rule for y
    refers to z while the rule for z refers back to y (exhibiting another
    type of loop). Conversely, the following set of equations would
    constitute a valid set of assignment statements: x = 10, y = z + 200,
    and z = x + 100.

    A model must not be overdetermined
    ......................................................................

    An SBML model must not be overdetermined; that is, a model must not
    define more equations than there are unknowns in a model.  A valid
    SBML model that does not contain AlgebraicRule structures cannot be
    overdetermined.

    LibSBML implements the static analysis procedure described in Appendix
    B of the SBML Level 3 specification for assessing whether a model is
    overdetermined.

    (In summary, assessing whether a given continuous, deterministic,
    mathematical model is overdetermined does not require dynamic
    analysis; it can be done by analyzing the system of equations created
    from the model. One approach is to construct a bipartite graph in
    which one set of vertices represents the variables and the other the
    set of vertices represents the equations.  Place edges between
    vertices such that variables in the system are linked to the equations
    that determine them.  For algebraic equations, there will be edges
    between the equation and each variable occurring in the equation.  For
    ordinary differential equations (such as those defined by rate rules
    or implied by the reaction rate definitions), there will be a single
    edge between the equation and the variable determined by that
    differential equation.  A mathematical model is overdetermined if the
    maximal matchings of the bipartite graph contain disconnected vertexes
    representing equations.  If one maximal matching has this property,
    then all the maximal matchings will have this property; i.e., it is
    only necessary to find one maximal matching.)

    Rule types for SBML Level 1
    ======================================================================

    SBML Level 1 uses a different scheme than SBML Level 2 and Level 3 for
    distinguishing rules; specifically, it uses an attribute whose value
    is drawn from an enumeration of 3 values.  LibSBML supports this using
    methods that work with the enumeration values  listed below.

    * RULE_TYPE_RATE: Indicates the rule is a 'rate' rule.

    * RULE_TYPE_SCALAR: Indicates the rule is a 'scalar' rule.

    * RULE_TYPE_INVALID: Indicates the rule type is unknown or not yet
    set.

    """

    __swig_setmethods__ = {}
    for _s in [Rule]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RateRule, name, value)
    __swig_getmethods__ = {}
    for _s in [Rule]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, RateRule, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(RateRule self, unsigned int level, unsigned int version) -> RateRule
        __init__(RateRule self, SBMLNamespaces sbmlns) -> RateRule


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            RateRule(SBMLNamespaces sbmlns)

        Creates a new RateRule using the given SBMLNamespaces object 'sbmlns'.

        The SBMLNamespaces object encapsulates SBML Level/Version/namespaces
        information.  It is used to communicate the SBML Level, Version, and
        (in Level 3) packages used in addition to SBML Level 3 Core.  A common
        approach to using libSBML's SBMLNamespaces facilities is to create an
        SBMLNamespaces object somewhere in a program once, then hand that
        object as needed to object constructors that accept SBMLNamespaces as
        arguments.

        Parameter 'sbmlns' is an SBMLNamespaces object.

        Throws SBMLConstructorException: Thrown if the given 'sbmlns' is
        inconsistent or incompatible with this object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            RateRule(long level, long version)

        Creates a new RateRule using the given SBML 'level' and 'version'
        values.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        RateRule.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this RateRule.

        Throws SBMLConstructorException: Thrown if the given 'level' and
        'version' combination are invalid or if this object is incompatible
        with the given level and version.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        """
        this = _libsbml.new_RateRule(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_RateRule
    __del__ = lambda self: None

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


        Creates and returns a deep copy of this RateRule object.

        Returns the (deep) copy of this RateRule object.

        """
        return _libsbml.RateRule_clone(self)


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


        Predicate returning 'True' if all the required attributes for this
        RateRule object have been set.

        In SBML Levels 2-3, the only required attribute for a RateRule object
        is 'variable'.  For Level 1, where the equivalent attribute is known
        by different names ('compartment', 'species', or 'name', depending on
        the type of object), there is an additional required attribute called
        'formula'.

        Returns 'True' if the required attributes have been set, 'False'
        otherwise.

        """
        return _libsbml.RateRule_hasRequiredAttributes(self)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(RateRule self, string oldid, string newid)


        Replaces all uses of a given 'SIdRef' type attribute value with
        another value.

        In SBML, object identifiers are of a data type called SId. In SBML
        Level 3, an explicit data type called SIdRef was introduced for
        attribute values that refer to SId values; in previous Levels of SBML,
        this data type did not exist and attributes were simply described to
        as 'referring to an identifier', but the effective data type was the
        same as SIdRef in Level 3.  These and other methods of libSBML refer
        to the type SIdRef for all Levels of SBML, even if the corresponding
        SBML specification did not explicitly name the data type.

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas in MathML content, comparing the referenced
        identifiers to the value of 'oldid'.  If any matches are found, the
        matching values are replaced with 'newid'.  The method does not
        descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.RateRule_renameSIdRefs(self, oldid, newid)

RateRule_swigregister = _libsbml.RateRule_swigregister
RateRule_swigregister(RateRule)

class Constraint(SBase):
    """

    An SBML constraint, for stating validity assumptions.

    The Constraint object class was introduced in SBML Level 2 Version 2
    as a mechanism for stating the assumptions under which a model is
    designed to operate.  The constraints are statements about permissible
    values of different quantities in a model. Constraints are not used to
    compute dynamical values for simulation or analysis, but rather, they
    serve an advisory role for simulation/analysis tools.

    SBML's Constraint object class has one required attribute, 'id', to
    give the parameter a unique identifier by which other parts of an SBML
    model definition can refer to it.  A Constraint object can also have
    an optional 'name' attribute of type '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).

    Constraint has one subelement, 'math', containing a MathML formula
    defining the condition of the constraint.  This formula will return a
    Boolean value of 'True' when the model is a valid state.  The formula
    can be an arbitrary expression referencing the variables and other
    entities in an SBML model.  The evaluation of 'math' and behavior of
    constraints are described in more detail below.

    In SBML Level 2 and SBML Level 3 Version 1, the 'math' subelement is
    required, and its formula must be a Boolean value.  In SBML Level 3
    Version 2, these restrictions were relaxed: the 'math' subelement is
    optional, and numeric values are allowed in Boolean contexts (a '0' is
    interpreted as 'False,' and all other values are interpreted as
    'True).'  If a Constraint with no 'math' is present in a Model, no
    restriction on the Model's behavior is implied or enforced.

    A Constraint structure also has an optional subelement called
    'message'. This can contain a message in XHTML format that may be
    displayed to the user when the condition of the formula in the 'math'
    subelement evaluates to a value of 'False.'  Software tools are not
    required to display the message, but it is recommended that they do so
    as a matter of best practice.  The XHTML content within a 'message'
    subelement must follow the same restrictions as for the 'notes'
    element on SBase described in in the SBML Level 2 specification;
    please consult the SBML specification document corresponding to the
    SBML Level and Version of your model for more information about the
    requirements for 'notes' content.

    Constraint 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.

    Semantics of Constraints
    ======================================================================

    In the context of a simulation, a Constraint has effect at all times t
    >= 0.  Each Constraint's 'math' subelement is first evaluated after
    any InitialAssignment definitions in a model at t = 0 and can
    conceivably trigger at that point.  (In other words, a simulation
    could fail a constraint immediately.)

    Constraint structures cannot and should not be used to compute the
    dynamical behavior of a model as part of, for example, simulation.
    Constraints may be used as input to non-dynamical analysis, for
    instance by expressing flux constraints for flux balance analysis.

    The results of a simulation of a model containing a constraint are
    invalid from any simulation time at and after a point when the
    function given by the 'math' subelement returns a value of 'False.'
    Invalid simulation results do not make a prediction of the behavior of
    the biochemical reaction network represented by the model.  The
    precise behavior of simulation tools is left undefined with respect to
    constraints.  If invalid results are detected with respect to a given
    constraint, the 'message' subelement may optionally be displayed to
    the user.  The simulation tool may also halt the simulation or clearly
    delimit in output data the simulation time point at which the
    simulation results become invalid.

    SBML does not impose restrictions on duplicate Constraint definitions
    or the order of evaluation of Constraint objects in a model.  It is
    possible for a model to define multiple constraints all with the same
    mathematical expression.  Since the failure of any constraint
    indicates that the model simulation has entered an invalid state, a
    system is not required to attempt to detect whether other constraints
    in the model have failed once any one constraint has failed.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Constraint, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Constraint, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_Constraint
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(Constraint self, unsigned int level, unsigned int version) -> Constraint
        __init__(Constraint self, SBMLNamespaces sbmlns) -> Constraint
        __init__(Constraint self, Constraint orig) -> Constraint


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            Constraint(SBMLNamespaces sbmlns)

        Creates a new Constraint using the given SBMLNamespaces object
        'sbmlns'.

        The SBMLNamespaces object encapsulates SBML Level/Version/namespaces
        information.  It is used to communicate the SBML Level, Version, and
        (in Level 3) packages used in addition to SBML Level 3 Core.  A common
        approach to using libSBML's SBMLNamespaces facilities is to create an
        SBMLNamespaces object somewhere in a program once, then hand that
        object as needed to object constructors that accept SBMLNamespaces as
        arguments.

        Parameter 'sbmlns' is an SBMLNamespaces object.

        Throws SBMLConstructorException: Thrown if the given 'sbmlns' is
        inconsistent or incompatible with this object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            Constraint(long level, long version)

        Creates a new Constraint using the given SBML 'level' and 'version'
        values.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        Constraint.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this Constraint.

        Throws SBMLConstructorException: Thrown if the given 'level' and
        'version' combination are invalid or if this object is incompatible
        with the given level and version.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            Constraint( Constraint orig)

        Copy constructor; creates a copy of this Constraint.

        Parameter 'orig' is the object to copy.

        """
        this = _libsbml.new_Constraint(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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


        Creates and returns a deep copy of this Constraint object.

        Returns the (deep) copy of this Constraint object.

        """
        return _libsbml.Constraint_clone(self)


    def getMessage(self):
        """
        getMessage(Constraint self) -> XMLNode


        Get the message, if any, associated with this Constraint

        Returns the message for this Constraint, as an XMLNode.

        """
        return _libsbml.Constraint_getMessage(self)


    def getMessageString(self):
        """
        getMessageString(Constraint self) -> string


        Get the message string, if any, associated with this Constraint

        Returns the message for this Constraint, as a string.

        """
        return _libsbml.Constraint_getMessageString(self)


    def getMath(self):
        """
        getMath(Constraint self) -> ASTNode


        Get the mathematical expression of this Constraint

        Returns the math for this Constraint, as an ASTNode, or 'None' if the
        math is not set.

        """
        return _libsbml.Constraint_getMath(self)


    def isSetMessage(self):
        """
        isSetMessage(Constraint self) -> bool


        Predicate returning 'True' if a message is defined for this
        Constraint.

        Returns 'True' if the message of this Constraint is set, 'False'
        otherwise.

        """
        return _libsbml.Constraint_isSetMessage(self)


    def isSetMath(self):
        """
        isSetMath(Constraint self) -> bool


        Predicate returning 'True' if a mathematical formula is defined for
        this Constraint.

        Returns 'True' if the 'math' subelement for this Constraint is set,
        'False' otherwise.

        """
        return _libsbml.Constraint_isSetMath(self)


    def setMessage(self, *args):
        """
        setMessage(Constraint self, XMLNode xhtml) -> int
        setMessage(Constraint self, string message, bool addXHTMLMarkup=False) -> int
        setMessage(Constraint self, string message) -> int


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            setMessage(string message, bool addXHTMLMarkup = false)

        Sets the message of this Constraint.

        Parameter 'message' is an XML string that is to be used as the content
        of the 'message' subelement of this object.

        Parameter 'addXHTMLMarkup' is a boolean indicating whether to wrap the
        contents of the 'message' argument with XHTML paragraph (<p>) tags.
        This is appropriate when the string in 'message' does not already
        containg the appropriate XHTML markup.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_OBJECT

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            setMessage(XMLNode xhtml)

        Sets the message of this Constraint.

        The XMLNode tree passed in 'xhtml' is copied.

        Parameter 'xhtml' is an XML tree containing XHTML content.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_OBJECT

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


    def setMath(self, math):
        """
        setMath(Constraint self, ASTNode math) -> int


        Sets the mathematical expression of this Constraint to a copy of the
        AST given as 'math'.

        Parameter 'math' is an ASTNode expression to be assigned as the 'math'
        subelement of this Constraint.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_OBJECT

        """
        return _libsbml.Constraint_setMath(self, math)


    def unsetMessage(self):
        """
        unsetMessage(Constraint self) -> int


        Unsets the 'message' subelement of this Constraint.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Constraint_unsetMessage(self)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(Constraint self, string oldid, string newid)


        Replaces all uses of a given 'SIdRef' type attribute value with
        another value.

        In SBML, object identifiers are of a data type called SId. In SBML
        Level 3, an explicit data type called SIdRef was introduced for
        attribute values that refer to SId values; in previous Levels of SBML,
        this data type did not exist and attributes were simply described to
        as 'referring to an identifier', but the effective data type was the
        same as SIdRef in Level 3.  These and other methods of libSBML refer
        to the type SIdRef for all Levels of SBML, even if the corresponding
        SBML specification did not explicitly name the data type.

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas in MathML content, comparing the referenced
        identifiers to the value of 'oldid'.  If any matches are found, the
        matching values are replaced with 'newid'.  The method does not
        descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.Constraint_renameSIdRefs(self, oldid, newid)


    def renameUnitSIdRefs(self, oldid, newid):
        """
        renameUnitSIdRefs(Constraint self, string oldid, string newid)


        Replaces all uses of a given 'UnitSIdRef' type attribute value with
        another value.

        In SBML, unit definitions have identifiers of type UnitSId.  In SBML
        Level 3, an explicit data type called UnitSIdRef was introduced for
        attribute values that refer to UnitSId values; in previous Levels of
        SBML, this data type did not exist and attributes were simply
        described to as 'referring to a unit identifier', but the effective
        data type was the same as UnitSIdRef in Level 3.  These and other
        methods of libSBML refer to the type UnitSIdRef for all Levels of
        SBML, even if the corresponding SBML specification did not explicitly
        name the data type.

        This method works by looking at all unit identifier attribute values
        (including, if appropriate, inside mathematical formulas), comparing
        the referenced unit identifiers to the value of 'oldid'.  If any
        matches are found, the matching values are replaced with 'newid'.  The
        method does not descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.Constraint_renameUnitSIdRefs(self, oldid, newid)


    def replaceSIDWithFunction(self, id, function):
        """
        replaceSIDWithFunction(Constraint self, string id, ASTNode function)


        Internal implementation method.

        """
        return _libsbml.Constraint_replaceSIDWithFunction(self, id, function)


    def getTypeCode(self):
        """
        getTypeCode(Constraint self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_CONSTRAINT (default).

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.Constraint_getTypeCode(self)


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


        Returns the XML element name of this object, which for Constraint, is
        always ''constraint'.'

        Returns the name of this element, i.e., ''constraint'.'

        """
        return _libsbml.Constraint_getElementName(self)


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


        Predicate returning 'True' if all the required elements for this
        Constraint object have been set.

        Note: The required elements for a Constraint object are:

        * 'math' (through SBML Level 3 Version 1 only; not  required in
        Level 3 Version 2+.)

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

        """
        return _libsbml.Constraint_hasRequiredElements(self)

Constraint_swigregister = _libsbml.Constraint_swigregister
Constraint_swigregister(Constraint)

class ListOfConstraints(ListOf):
    """

    A list of Constraint objects.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfConstraints, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfConstraints, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ListOfConstraints self, unsigned int level, unsigned int version) -> ListOfConstraints
        __init__(ListOfConstraints self, SBMLNamespaces sbmlns) -> ListOfConstraints


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfConstraints(SBMLNamespaces sbmlns)

        Creates a new ListOfConstraints object.

        The object is constructed such that it is valid for the SBML Level and
        Version combination determined by the SBMLNamespaces object in
        'sbmlns'.

        Parameter 'sbmlns' is an SBMLNamespaces object that is used to
        determine the characteristics of the ListOfConstraints object to be
        created.

        Throws SBMLConstructorException: Thrown if the given 'sbmlns' is
        inconsistent or incompatible with this object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfConstraints(long level, long version)

        Creates a new ListOfConstraints object.

        The object is constructed such that it is valid for the given SBML
        Level and Version combination.

        Parameter 'level' is the SBML Level.

        Parameter 'version' is the Version within the SBML Level.

        Throws SBMLConstructorException: Thrown if the given 'level' and
        'version' combination are invalid or if this object is incompatible
        with the given level and version.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        """
        this = _libsbml.new_ListOfConstraints(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ListOfConstraints self) -> ListOfConstraints


        Creates and returns a deep copy of this ListOfConstraints object.

        Returns the (deep) copy of this ListOfConstraints object.

        """
        return _libsbml.ListOfConstraints_clone(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfConstraints self) -> int


        Returns the libSBML type code for the objects contained in this ListOf
        (i.e., Constraint objects, if the list is non-empty).

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for the objects contained in this ListOf
        instance: SBML_CONSTRAINT (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfConstraints_getItemTypeCode(self)


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


        Returns the XML element name of this object.

        For ListOfConstraints, the XML element name is ''listOfConstraints'.'

        Returns the name of this element.

        """
        return _libsbml.ListOfConstraints_getElementName(self)


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


        Get a Constraint from the ListOfConstraints.

        Parameter 'n' is the index number of the Constraint to get.

        Returns the nth Constraint in this ListOfConstraints. If the index 'n'
        is invalid, 'None' is returned.

        See also size().

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


    def remove(self, n):
        """
        remove(ListOfConstraints self, unsigned int n) -> Constraint


        Removes the nth item from this ListOfConstraints items and returns a
        pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the item to remove.

        See also size().

        """
        return _libsbml.ListOfConstraints_remove(self, n)

    __swig_destroy__ = _libsbml.delete_ListOfConstraints
    __del__ = lambda self: None
ListOfConstraints_swigregister = _libsbml.ListOfConstraints_swigregister
ListOfConstraints_swigregister(ListOfConstraints)

class Reaction(SBase):
    """

    An SBML reaction between species in an SBML model.

    A reaction represents any transformation, transport or binding
    process, typically a chemical reaction, that can change the quantity
    of one or more species.  In SBML, a reaction is defined primarily in
    terms of the participating reactants and products (and their
    corresponding stoichiometries), along with optional modifier species,
    an optional rate at which the reaction takes place, and optional
    parameters.

    As with other major objects in SBML, Reaction has a mandatory
    attribute, 'id', used to give the reaction an identifier.  The
    identifier must be a text string conforming to the identifer syntax
    permitted in SBML.  In SBML Level 2 and Level 3, the reaction 'id'
    identifier can be used in mathematical formulas elsewhere in an SBML
    model to represent the rate of that reaction; this usage is explained
    below.  Reaction also has an optional 'name' attribute, of type
    'string.'  The 'id' and 'name' must be used according to the
    guidelines described in the SBML specification.

    The species participating as reactants, products, and/or modifiers in
    a reaction are declared using lists of SpeciesReference and/or
    ModifierSpeciesReference instances stored in subelements
    'listOfReactants', 'listOfProducts' and 'listOfModifiers'.  Certain
    restrictions are placed on the appearance of species in reaction
    definitions:

    * The ability of a species to appear as a reactant or product of any
    reaction in a model is governed by certain flags in that species'
    definition; see the definition of Species for more information.

    * Any species appearing in the mathematical formula of the subelement
    'kineticLaw' (described below) of a Reaction must be declared in at
    least one of that Reaction's lists of reactants, products, and/or
    modifiers.  Put another way, it is an error for a reaction's kinetic
    law formula to refer to species that have not been declared for that
    reaction.

    * For SBML Levels 1, 2, and SBML Level 3 Version 1, a  reaction
    definition can contain an empty list of reactants or an empty list of
    products, but it must have at least one reactant or product; in other
    words, a reaction without any reactant or product species is not
    permitted.  (This restriction does not apply to modifier species,
    which remain optional in all cases.)  In SBML  Level 3 Version 2, this
    requirement was dropped, allowing  the creation of reactions with
    neither reactants nor products. A reaction can contain up to one
    KineticLaw object in a subelement named 'kineticLaw'.  It defines the
    speed at which the process defined by the reaction takes place.  The
    description of KineticLaw provides more details about its use.  Note
    that although the inclusion of a KineticLaw object in an instance of a
    Reaction component is optional, there is no useful default that can be
    substituted in place of a missing rate expression in a reaction.
    Moreover, a reaction's rate cannot be defined in any other way in SBML
    ---InitialAssignment, AssignmentRule, RateRule, AlgebraicRule, Event,
    and other constructs in SBML cannot be used to set the reaction rate
    separately.  Nevertheless, for some modeling applications, reactions
    without any defined rate can be perfectly acceptable.

    Reaction also has a boolean attribute named 'reversible' for
    indicating whether the reaction is reversible.  This attribute is
    optional in SBML Level 2, with a default of 'True;' it is mandatory in
    SBML Level 3 (with no default value).  To say that a reaction is
    reversible is to say it can proceed in either the forward or the
    reverse direction.  Although the reversibility of a reaction can
    sometimes be deduced by inspecting its rate expression, this is not
    always the case, especially for complicated expressions.  Moreover,
    the need in SBML to allow rate expressions (i.e., KineticLaw) to be
    optional leads to the need for a separate flag indicating
    reversibility.  Note that labeling a reaction as irreversible is an
    assertion that the reaction always proceeds in the given forward
    direction.  (Why else would it be flagged as irreversible?)  This
    implies the rate expression in the KineticLaw always has a non-
    negative value during simulations.  Software tools could provide a
    means of optionally testing that this condition holds. The presence of
    reversibility information in two places (i.e., the rate expression and
    the 'reversible' attribute on Reaction) leaves open the possibility
    that a model could contain contradictory information, but the creation
    of such a model would be an error on the part of the software
    generating it.

    The Reaction object class has another boolean attribute called 'fast'.
    This attribute is optional in SBML Level 2, with a default of 'False;'
    it is mandatory in SBML Level 3 (with no default value).   In SBML
    Level 3 Version 2, a value of 'True' for the 'fast' attribute is
    deprecated in favor of all reactions having a 'fast' value  of
    'False.'  It is used to indicate that a reaction occurs on a vastly
    faster time scale than others in a system.  Readers are directed to
    the SBML Level 2 Version 4 specification, which provides more detail
    about the conditions under which a reaction can be considered to be
    fast in this sense.  SBML Level 1 and Level 2 Version 1 incorrectly
    claimed that software tools could ignore this attribute if they did
    not implement support for the corresponding concept; however, further
    research in SBML has revealed that this is not true, and 'fast' cannot
    be ignored if it is set to 'True.'  SBML Level 2 Versions 2-4
    therefore stipulate that if a model has any reactions with 'fast' set
    to 'True,' a software tool must be able to respect the attribute or
    else indicate to the user that it does not have the capacity to do so.
    Analysis software cannot ignore the value of the 'fast' attribute
    because doing so may lead to different results as compared to a
    software system that does make use of 'fast'.

    In SBML Level 3 Version 2, the 'fast' attribute was  removed.  All
    reactions are assumed to be equivalent to reactions in previous
    levels/versions that have a 'fast' attribute value of 'False.'  Users
    should be aware that even for previous levels/versions of the
    specification, 'fast' attribute values of 'True' never achieved
    widespread support, and many software packages may ignore it.  To
    achieve the same or similar  effects as setting the fast attribute to
    'True' for a given  reaction, the KineticLaw attribute should be
    constructed to  produce a value in the desired time scale, or else the
    reaction could be replaced with an AssignmentRule or  AlgebraicRule.

    In SBML Level 3, the Reaction object has an additional optional
    attribute named 'compartment', whose value must be the identifier of a
    compartment defined in the enclosing Model object. The 'compartment'
    attribute can be used to indicate the compartment in which the
    reaction is assumed to take place.  If the attribute is present, its
    value must be the identifier of a Compartment object defined in the
    enclosing Model object.  Similar to the 'reversible' attribute, the
    value of the 'compartment' attribute has no direct impact on the
    construction of mathematical equations for the SBML model.  When a
    kinetic law is given for a reaction, the compartment location may
    already be implicit in the kinetic law (although this cannot always be
    guaranteed).  Nevertheless, software tools may find the 'compartment'
    attribute value useful for such purposes as analyzing the structure of
    the model, guiding the modeler in constructing correct rate formulas,
    and visualization purposes.

    Readers are urged to read the SBML specification for more details
    about the proper use of Reaction.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Reaction, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Reaction, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_Reaction
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(Reaction self, unsigned int level, unsigned int version) -> Reaction
        __init__(Reaction self, SBMLNamespaces sbmlns) -> Reaction
        __init__(Reaction self, Reaction orig) -> Reaction


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            Reaction(SBMLNamespaces sbmlns)

        Creates a new Reaction using the given SBMLNamespaces object 'sbmlns'.

        The SBMLNamespaces object encapsulates SBML Level/Version/namespaces
        information.  It is used to communicate the SBML Level, Version, and
        (in Level 3) packages used in addition to SBML Level 3 Core.  A common
        approach to using libSBML's SBMLNamespaces facilities is to create an
        SBMLNamespaces object somewhere in a program once, then hand that
        object as needed to object constructors that accept SBMLNamespaces as
        arguments.

        Parameter 'sbmlns' is an SBMLNamespaces object.

        Throws SBMLConstructorException: Thrown if the given 'sbmlns' is
        inconsistent or incompatible with this object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            Reaction(long level, long version)

        Creates a new Reaction using the given SBML 'level' and 'version'
        values.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        Reaction.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this Reaction.

        Throws SBMLConstructorException: Thrown if the given 'level' and
        'version' combination are invalid or if this object is incompatible
        with the given level and version.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            Reaction(Reaction orig)

        Copy constructor; creates a copy of this Reaction.

        Parameter 'orig' is the object to copy.

        """
        this = _libsbml.new_Reaction(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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


        Creates and returns a deep copy of this Reaction object.

        Returns the (deep) copy of this Reaction object.

        """
        return _libsbml.Reaction_clone(self)


    def getElementBySId(self, id):
        """
        getElementBySId(Reaction self, string id) -> SBase


        Returns the first child element found that has the given 'id' in the
        model-wide SId namespace, or 'None' if no such object is found.

        Parameter 'id' is string representing the id of the object to find.

        Returns pointer to the first element found with the given 'id'.

        """
        return _libsbml.Reaction_getElementBySId(self, id)


    def getElementByMetaId(self, metaid):
        """
        getElementByMetaId(Reaction self, string metaid) -> SBase


        Returns the first child element it can find with the given 'metaid',
        or 'None' if no such object is found.

        Parameter 'metaid' is string representing the metaid of the object to
        find.

        Returns pointer to the first element found with the given 'metaid'.

        """
        return _libsbml.Reaction_getElementByMetaId(self, metaid)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(Reaction self, string oldid, string newid)


        Replaces all uses of a given 'SIdRef' type attribute value with
        another value.

        In SBML, object identifiers are of a data type called SId. In SBML
        Level 3, an explicit data type called SIdRef was introduced for
        attribute values that refer to SId values; in previous Levels of SBML,
        this data type did not exist and attributes were simply described to
        as 'referring to an identifier', but the effective data type was the
        same as SIdRef in Level 3.  These and other methods of libSBML refer
        to the type SIdRef for all Levels of SBML, even if the corresponding
        SBML specification did not explicitly name the data type.

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas in MathML content, comparing the referenced
        identifiers to the value of 'oldid'.  If any matches are found, the
        matching values are replaced with 'newid'.  The method does not
        descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.Reaction_renameSIdRefs(self, oldid, newid)


    def initDefaults(self):
        """
        initDefaults(Reaction self)


        Initializes the fields of this Reaction object to 'typical' default
        values.

        The SBML Reaction component has slightly different aspects and default
        attribute values in different SBML Levels and Versions. This method
        sets the values to certain common defaults, based mostly on what they
        are in SBML Level 2.  Specifically:

        * Sets the 'reversible' attribute to 'True'

        * Sets the 'fast' attribute to 'False'

        * Marks the 'fast' attribute as not having been set for SBML Level
        2, but as having been set for SBML Level 1 and SBML Level 3.

        WARNING:

        SBML definitions before SBML Level 2 Version 2 incorrectly indicated
        that software tools could ignore the 'fast' attribute if they did not
        implement support for the corresponding concept; however, further
        research in SBML has revealed that this is not true, and 'fast' cannot
        be ignored if it is set to 'True.' Beginning with SBML Level 2
        Versions 2, the SBML specifications therefore stipulate that if a
        model has any reactions with 'fast' set to 'True,' a software tool
        must be able to respect the attribute or else indicate to the user
        that it does not have the capacity to do so.  Readers are directed to
        the SBML specifications, which provides more detail about the
        conditions under which a reaction can be considered to be fast in this
        sense.

        """
        return _libsbml.Reaction_initDefaults(self)


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


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

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is now recommended to use the
        getIdAttribute() function instead.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns the id of this Reaction.

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.Reaction_getId(self)


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


        Returns the value of the 'name' attribute of this Reaction object.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns the name of this SBML object, or the empty string if not set
        or unsettable.

        See also getIdAttribute(), isSetName(), setName(), unsetName().

        """
        return _libsbml.Reaction_getName(self)


    def getKineticLaw(self, *args):
        """
        getKineticLaw(Reaction self) -> KineticLaw
        getKineticLaw(Reaction self) -> KineticLaw


        Returns the KineticLaw object contained in this Reaction.

        Returns the KineticLaw instance.

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


    def getReversible(self):
        """
        getReversible(Reaction self) -> bool


        Returns the value of the 'reversible' attribute on the Reaction as a
        boolean value.

        Returns the reversibility status of this Reaction.

        """
        return _libsbml.Reaction_getReversible(self)


    def getFast(self):
        """
        getFast(Reaction self) -> bool


        Returns the value of the 'fast' attribute of this Reaction.

        In SBML Level 3 Version 2, the 'fast' attribute was  removed.  All
        reactions are assumed to be equivalent to reactions in previous
        levels/versions that have a 'fast' attribute value of 'False.'  Users
        should be aware that even for previous levels/versions of the
        specification, 'fast' attribute values of 'True' never achieved
        widespread support, and many software packages may ignore it.  To
        achieve the same or similar  effects as setting the fast attribute to
        'True' for a given  reaction, the KineticLaw attribute should be
        constructed to  produce a value in the desired time scale, or else the
        reaction could be replaced with an AssignmentRule or  AlgebraicRule.

        Returns the 'fast' status of this Reaction.

        WARNING:

        SBML definitions before SBML Level 2 Version 2 incorrectly indicated
        that software tools could ignore the 'fast' attribute if they did not
        implement support for the corresponding concept; however, further
        research in SBML has revealed that this is not true, and 'fast' cannot
        be ignored if it is set to 'True.' Beginning with SBML Level 2
        Versions 2, the SBML specifications therefore stipulate that if a
        model has any reactions with 'fast' set to 'True,' a software tool
        must be able to respect the attribute or else indicate to the user
        that it does not have the capacity to do so.  Readers are directed to
        the SBML specifications, which provides more detail about the
        conditions under which a reaction can be considered to be fast in this
        sense.

        """
        return _libsbml.Reaction_getFast(self)


    def getCompartment(self):
        """
        getCompartment(Reaction self) -> string


        (SBML Level 3 only) Returns the value of the 'compartment' attribute
        on the Reaction.

        Returns the compartment of this Reaction.

        Note: The 'compartment' attribute is available in SBML Level 3, but is
        not present on Reaction in lower Levels of SBML.

        """
        return _libsbml.Reaction_getCompartment(self)


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


        Predicate returning 'True' if this Reaction's 'id' attribute is set.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns 'True' if the 'id' attribute of this SBML object is set,
        'False' otherwise.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is recommended that callers use
        isSetIdAttribute() instead.

        See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(),
        isSetIdAttribute().

        """
        return _libsbml.Reaction_isSetId(self)


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


        Predicate returning 'True' if this Reaction's 'name' attribute is set.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns 'True' if the 'name' attribute of this SBML object is set,
        'False' otherwise.

        See also getName(), setName(), unsetName().

        """
        return _libsbml.Reaction_isSetName(self)


    def isSetKineticLaw(self):
        """
        isSetKineticLaw(Reaction self) -> bool


        Predicate returning 'True' if this Reaction contains a kinetic law
        object.

        Returns 'True' if a KineticLaw is present in this Reaction,, 'False'
        otherwise.

        """
        return _libsbml.Reaction_isSetKineticLaw(self)


    def isSetFast(self):
        """
        isSetFast(Reaction self) -> bool


        Predicate returning 'True' if the value of the 'fast' attribute on
        this Reaction is set.

        In SBML Level 3 Version 2, the 'fast' attribute was  removed.  All
        reactions are assumed to be equivalent to reactions in previous
        levels/versions that have a 'fast' attribute value of 'False.'  Users
        should be aware that even for previous levels/versions of the
        specification, 'fast' attribute values of 'True' never achieved
        widespread support, and many software packages may ignore it.  To
        achieve the same or similar  effects as setting the fast attribute to
        'True' for a given  reaction, the KineticLaw attribute should be
        constructed to  produce a value in the desired time scale, or else the
        reaction could be replaced with an AssignmentRule or  AlgebraicRule.

        Returns 'True' if the 'fast' attribute is set, 'False' otherwise.

        WARNING:

        SBML definitions before SBML Level 2 Version 2 incorrectly indicated
        that software tools could ignore the 'fast' attribute if they did not
        implement support for the corresponding concept; however, further
        research in SBML has revealed that this is not true, and 'fast' cannot
        be ignored if it is set to 'True.' Beginning with SBML Level 2
        Versions 2, the SBML specifications therefore stipulate that if a
        model has any reactions with 'fast' set to 'True,' a software tool
        must be able to respect the attribute or else indicate to the user
        that it does not have the capacity to do so.  Readers are directed to
        the SBML specifications, which provides more detail about the
        conditions under which a reaction can be considered to be fast in this
        sense.

        """
        return _libsbml.Reaction_isSetFast(self)


    def isSetCompartment(self):
        """
        isSetCompartment(Reaction self) -> bool


        Predicate returning 'True' if this Reaction's 'compartment' attribute
        is set.

        Returns 'True' if the 'compartment' attribute of this Reaction is set,
        'False' otherwise.

        Note: The 'compartment' attribute is available in SBML Level 3, but is
        not present on Reaction in lower Levels of SBML.

        """
        return _libsbml.Reaction_isSetCompartment(self)


    def isSetReversible(self):
        """
        isSetReversible(Reaction self) -> bool


        Predicate returning 'True' if this Reaction's 'reversible' attribute
        is set.

        Returns 'True' if the 'reversible' attribute of this Reaction is set,
        'False' otherwise.

        """
        return _libsbml.Reaction_isSetReversible(self)


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


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

        The string 'sid' is copied.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Parameter 'sid' is the string to use as the identifier of this object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.Reaction_setId(self, sid)


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


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

        The string in 'name' is copied.

        Parameter 'name' is the new name for the SBML object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Reaction_setName(self, name)


    def setKineticLaw(self, kl):
        """
        setKineticLaw(Reaction self, KineticLaw kl) -> int


        Sets the 'kineticLaw' subelement of this Reaction to a copy of the
        given KineticLaw object.

        Parameter 'kl' is the KineticLaw object to use.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        """
        return _libsbml.Reaction_setKineticLaw(self, kl)


    def setReversible(self, value):
        """
        setReversible(Reaction self, bool value) -> int


        Sets the value of the 'reversible' attribute of this Reaction.

        Parameter 'value' is the value of the 'reversible' attribute.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.Reaction_setReversible(self, value)


    def setFast(self, value):
        """
        setFast(Reaction self, bool value) -> int


        Sets the value of the 'fast' attribute of this Reaction.

        In SBML Level 3 Version 2, the 'fast' attribute was  removed.  All
        reactions are assumed to be equivalent to reactions in previous
        levels/versions that have a 'fast' attribute value of 'False.'  Users
        should be aware that even for previous levels/versions of the
        specification, 'fast' attribute values of 'True' never achieved
        widespread support, and many software packages may ignore it.  To
        achieve the same or similar  effects as setting the fast attribute to
        'True' for a given  reaction, the KineticLaw attribute should be
        constructed to  produce a value in the desired time scale, or else the
        reaction could be replaced with an AssignmentRule or  AlgebraicRule.

        Calling this function with an argument of 'True' for an SBML Level 3
        Version 2 Reaction will not set the value, as the attribute does not
        exist for that level/version.

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        Parameter 'value' is the value of the 'fast' attribute.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        WARNING:

        SBML definitions before SBML Level 2 Version 2 incorrectly indicated
        that software tools could ignore the 'fast' attribute if they did not
        implement support for the corresponding concept; however, further
        research in SBML has revealed that this is not true, and 'fast' cannot
        be ignored if it is set to 'True.' Beginning with SBML Level 2
        Versions 2, the SBML specifications therefore stipulate that if a
        model has any reactions with 'fast' set to 'True,' a software tool
        must be able to respect the attribute or else indicate to the user
        that it does not have the capacity to do so.  Readers are directed to
        the SBML specifications, which provides more detail about the
        conditions under which a reaction can be considered to be fast in this
        sense.

        """
        return _libsbml.Reaction_setFast(self, value)


    def setCompartment(self, sid):
        """
        setCompartment(Reaction self, string sid) -> int


        Sets the value of the 'compartment' attribute of this Reaction.

        The string 'sid' is copied.

        Parameter 'sid' is the string to use as the compartment of this
        Reaction.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        Note: The 'compartment' attribute is available in SBML Level 3, but is
        not present on Reaction in lower Levels of SBML.

        """
        return _libsbml.Reaction_setCompartment(self, sid)


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


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

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getName(), setName(), isSetName().

        """
        return _libsbml.Reaction_unsetName(self)


    def unsetKineticLaw(self):
        """
        unsetKineticLaw(Reaction self) -> int


        Unsets the 'kineticLaw' subelement of this Reaction.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Reaction_unsetKineticLaw(self)


    def unsetFast(self):
        """
        unsetFast(Reaction self) -> int


        Unsets the value of the 'fast' attribute of this Reaction.

        In SBML Level 3 Version 2, the 'fast' attribute was  removed.  All
        reactions are assumed to be equivalent to reactions in previous
        levels/versions that have a 'fast' attribute value of 'False.'  Users
        should be aware that even for previous levels/versions of the
        specification, 'fast' attribute values of 'True' never achieved
        widespread support, and many software packages may ignore it.  To
        achieve the same or similar  effects as setting the fast attribute to
        'True' for a given  reaction, the KineticLaw attribute should be
        constructed to  produce a value in the desired time scale, or else the
        reaction could be replaced with an AssignmentRule or  AlgebraicRule.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        WARNING:

        SBML definitions before SBML Level 2 Version 2 incorrectly indicated
        that software tools could ignore the 'fast' attribute if they did not
        implement support for the corresponding concept; however, further
        research in SBML has revealed that this is not true, and 'fast' cannot
        be ignored if it is set to 'True.' Beginning with SBML Level 2
        Versions 2, the SBML specifications therefore stipulate that if a
        model has any reactions with 'fast' set to 'True,' a software tool
        must be able to respect the attribute or else indicate to the user
        that it does not have the capacity to do so.  Readers are directed to
        the SBML specifications, which provides more detail about the
        conditions under which a reaction can be considered to be fast in this
        sense.

        """
        return _libsbml.Reaction_unsetFast(self)


    def unsetCompartment(self):
        """
        unsetCompartment(Reaction self) -> int


        Unsets the value of the 'compartment' attribute of this Reaction.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        * LIBSBML_OPERATION_FAILED

        Note: The 'compartment' attribute is available in SBML Level 3, but is
        not present on Reaction in lower Levels of SBML.

        """
        return _libsbml.Reaction_unsetCompartment(self)


    def unsetReversible(self):
        """
        unsetReversible(Reaction self) -> int


        Unsets the value of the 'reversible' attribute of this Reaction.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Reaction_unsetReversible(self)


    def addReactant(self, *args):
        """
        addReactant(Reaction self, SpeciesReference sr) -> int
        addReactant(Reaction self, Species species, double stoichiometry=1.0, string id, bool constant=True) -> int
        addReactant(Reaction self, Species species, double stoichiometry=1.0, string id) -> int
        addReactant(Reaction self, Species species, double stoichiometry=1.0) -> int
        addReactant(Reaction self, Species species) -> int


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            addReactant(Species species, double stoichiometry = 1.0,
        string id = '', bool constant = true)

        Adds the given species as a reactant with the given stoichiometry

        Parameter 'species' is the species to be added as reactant.

        Parameter 'stoichiometry' is an optional parameter specifying the
        stoichiometry of the added reactant (defaulting to 1).

        Parameter 'id' is an optional id to be given to the species reference
        that will be created. (defaulting to empty string, i.e. not set).

        Parameter 'constant' is an attribute specifying whether the species
        reference is constant or not (defaulting to true).

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_DUPLICATE_OBJECT_ID

        Note: This method should be used with some caution.  The fact that
        this method copies the object passed to it means that the caller will
        be left holding a physically different object instance than the one
        contained inside this object.  Changes made to the original object
        instance (such as resetting attribute values) will not affect the
        instance in this object.  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 other methods on this class
        (particularly a corresponding method whose name begins with the word
        create) for alternatives that do not lead to these issues.

        Note: the Species object itself is NOT added to the model

        See also createProduct().

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            addReactant(SpeciesReference sr)

        Adds a given SpeciesReference object as a reactant in this Reaction.

        The SpeciesReference instance in 'sr' is copied.

        Parameter 'sr' is a SpeciesReference object referring to a Species in
        the enclosing Model.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_DUPLICATE_OBJECT_ID

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_OPERATION_FAILED

        Note: This method should be used with some caution.  The fact that
        this method copies the object passed to it means that the caller will
        be left holding a physically different object instance than the one
        contained inside this object.  Changes made to the original object
        instance (such as resetting attribute values) will not affect the
        instance in this object.  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 other methods on this class
        (particularly a corresponding method whose name begins with the word
        create) for alternatives that do not lead to these issues.

        See also createReactant().

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


    def addProduct(self, *args):
        """
        addProduct(Reaction self, SpeciesReference sr) -> int
        addProduct(Reaction self, Species species, double stoichiometry=1.0, string id, bool constant=True) -> int
        addProduct(Reaction self, Species species, double stoichiometry=1.0, string id) -> int
        addProduct(Reaction self, Species species, double stoichiometry=1.0) -> int
        addProduct(Reaction self, Species species) -> int


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            addProduct(Species species, double stoichiometry = 1.0,
        string id = '', bool constant = true)

        Adds the given species as a product with the given stoichiometry

        Parameter 'species' is the species to be added as product.

        Parameter 'stoichiometry' is an optional parameter specifying the
        stoichiometry of the added product (defaulting to 1).

        Parameter 'id' is an optional id to be given to the species reference
        that will be created. (defaulting to empty string, i.e. not set).

        Parameter 'constant' is an attribute specifying whether the species
        reference is constant or not (defaulting to true).

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_DUPLICATE_OBJECT_ID

        Note: This method should be used with some caution.  The fact that
        this method copies the object passed to it means that the caller will
        be left holding a physically different object instance than the one
        contained inside this object.  Changes made to the original object
        instance (such as resetting attribute values) will not affect the
        instance in this object.  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 other methods on this class
        (particularly a corresponding method whose name begins with the word
        create) for alternatives that do not lead to these issues.

        Note: the Species object itself is NOT added to the model

        See also createProduct().

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            addProduct(SpeciesReference sr)

        Adds a given SpeciesReference object as a product in this Reaction.

        The SpeciesReference instance in 'sr' is copied.

        Parameter 'sr' is a SpeciesReference object referring to a Species in
        the enclosing Model.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_OPERATION_FAILED

        Note: This method should be used with some caution.  The fact that
        this method copies the object passed to it means that the caller will
        be left holding a physically different object instance than the one
        contained inside this object.  Changes made to the original object
        instance (such as resetting attribute values) will not affect the
        instance in this object.  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 other methods on this class
        (particularly a corresponding method whose name begins with the word
        create) for alternatives that do not lead to these issues.

        See also createProduct().

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


    def addModifier(self, *args):
        """
        addModifier(Reaction self, ModifierSpeciesReference msr) -> int
        addModifier(Reaction self, Species species, string id) -> int
        addModifier(Reaction self, Species species) -> int


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            addModifier(Species species, string id = '')

        Adds the given species as a modifier to this reaction

        Parameter 'species' is the species to be added as modifier.

        Parameter 'id' is an optional id to be given to the species reference
        that will be created. (defaulting to empty string, i.e. not set).

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_DUPLICATE_OBJECT_ID

        Note: This method should be used with some caution.  The fact that
        this method copies the object passed to it means that the caller will
        be left holding a physically different object instance than the one
        contained inside this object.  Changes made to the original object
        instance (such as resetting attribute values) will not affect the
        instance in this object.  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 other methods on this class
        (particularly a corresponding method whose name begins with the word
        create) for alternatives that do not lead to these issues.

        Note: the Species object itself is NOT added to the model

        See also createModifier().

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            addModifier(ModifierSpeciesReference msr)

        Adds a given ModifierSpeciesReference object as a product in this
        Reaction.

        The ModifierSpeciesReference instance in 'msr' is copied.

        Parameter 'msr' is a ModifierSpeciesReference object referring to a
        Species in the enclosing Model.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_DUPLICATE_OBJECT_ID

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_OPERATION_FAILED

        Note: This method should be used with some caution.  The fact that
        this method copies the object passed to it means that the caller will
        be left holding a physically different object instance than the one
        contained inside this object.  Changes made to the original object
        instance (such as resetting attribute values) will not affect the
        instance in this object.  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 other methods on this class
        (particularly a corresponding method whose name begins with the word
        create) for alternatives that do not lead to these issues.

        See also createModifier().

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


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


        Creates a new SpeciesReference, adds it to this Reaction's list of
        reactants, and returns it.

        Returns a new SpeciesReference object.

        """
        return _libsbml.Reaction_createReactant(self)


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


        Creates a new SpeciesReference, adds it to this Reaction's list of
        products, and returns it.

        Returns a new SpeciesReference object.

        """
        return _libsbml.Reaction_createProduct(self)


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


        Creates a new ModifierSpeciesReference, adds it to this Reaction's
        list of modifiers and returns it.

        Returns a new ModifierSpeciesReference object.

        """
        return _libsbml.Reaction_createModifier(self)


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


        Creates a new KineticLaw object, installs it as this Reaction's
        'kineticLaw' subelement, and returns it.

        If this Reaction had a previous KineticLaw, it will be destroyed.

        Returns the new KineticLaw object.

        """
        return _libsbml.Reaction_createKineticLaw(self)


    def getListOfReactants(self, *args):
        """
        getListOfReactants(Reaction self) -> ListOfSpeciesReferences
        getListOfReactants(Reaction self) -> ListOfSpeciesReferences


        Returns the list of reactants in this Reaction object.

        Returns the ListOfSpeciesReferences containing the references to the
        species acting as reactants in this reaction.

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


    def getListOfProducts(self, *args):
        """
        getListOfProducts(Reaction self) -> ListOfSpeciesReferences
        getListOfProducts(Reaction self) -> ListOfSpeciesReferences


        Returns the list of products in this Reaction object.

        Returns the ListOfSpeciesReferences containing the references to the
        species acting as products in this reaction.

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


    def getListOfModifiers(self, *args):
        """
        getListOfModifiers(Reaction self) -> ListOfSpeciesReferences
        getListOfModifiers(Reaction self) -> ListOfSpeciesReferences


        Returns the list of modifiers in this Reaction object.

        Returns the ListOfSpeciesReferences containing the references to the
        species acting as modifiers in this reaction.

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


    def getReactant(self, *args):
        """
        getReactant(Reaction self, unsigned int n) -> SpeciesReference
        getReactant(Reaction self, unsigned int n) -> SpeciesReference
        getReactant(Reaction self, string species) -> SpeciesReference
        getReactant(Reaction self, string species) -> SpeciesReference


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getReactant(string species)

        Returns the reactant species (as a SpeciesReference object) having  a
        specific identifier in this Reaction.

        Parameter 'species' is the identifier of the reactant Species
        ('species'  attribute of the reactant SpeciesReference object).

        Returns a SpeciesReference object, or 'None' if no species with the
        given identifier 'species' appears as a reactant in this Reaction.

        ______________________________________________________________________
        Method variant with the following signature:

            getReactant(long n)

        Returns the nth reactant species (as a SpeciesReference object)  in
        the list of reactants in this Reaction.

        Callers should first call getNumReactants() to find out how many
        reactants there are, to avoid using an invalid index number.

        Parameter 'n' is the index of the reactant sought.

        Returns the nth reactant (as a SpeciesReference object) of this
        Reaction. If the index 'n' is invalid, 'None' is returned.

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


    def getProduct(self, *args):
        """
        getProduct(Reaction self, unsigned int n) -> SpeciesReference
        getProduct(Reaction self, unsigned int n) -> SpeciesReference
        getProduct(Reaction self, string species) -> SpeciesReference
        getProduct(Reaction self, string species) -> SpeciesReference


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getProduct(string species)

        Returns the product species (as a SpeciesReference object) having  a
        specific identifier in this Reaction.

        Parameter 'species' is the identifier of the product Species
        ('species' attribute of the product SpeciesReference object).

        Returns a SpeciesReference object, or 'None' if no species with the
        given identifier 'species' appears as a product in this Reaction.

        ______________________________________________________________________
        Method variant with the following signature:

            getProduct(long n)

        Returns the nth product species (as a SpeciesReference object)  in the
        list of products in this Reaction.

        Callers should first call getNumProducts() to find out how many
        products there are, to avoid using an invalid index number.

        Parameter 'n' is the index of the product sought.

        Returns the nth product (as a SpeciesReference object) of this
        Reaction. If the index 'n' is invalid, 'None' is returned.

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


    def getModifier(self, *args):
        """
        getModifier(Reaction self, unsigned int n) -> ModifierSpeciesReference
        getModifier(Reaction self, unsigned int n) -> ModifierSpeciesReference
        getModifier(Reaction self, string species) -> ModifierSpeciesReference
        getModifier(Reaction self, string species) -> ModifierSpeciesReference


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getModifier(string species)

        Returns the modifier species (as a ModifierSpeciesReference object)
        having a specific identifier in this Reaction.

        Parameter 'species' is the identifier of the modifier Species
        ('species'  attribute of the ModifierSpeciesReference object).

        Returns a ModifierSpeciesReference object, or 'None' if no species
        with the given identifier 'species' appears as a modifier in this
        Reaction.

        ______________________________________________________________________
        Method variant with the following signature:

            getModifier(long n)

        Returns the nth modifier species (as a ModifierSpeciesReference
        object)  in the list of modifiers of this Reaction.

        Callers should first call getNumModifiers() to find out how many
        modifiers there are, to avoid using an invalid index number.

        Parameter 'n' is the index of the modifier species sought.

        Returns the nth modifier (as a ModifierSpeciesReference object) of
        this Reaction. If the index 'n' is invalid, 'None' is returned.

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


    def getNumReactants(self):
        """
        getNumReactants(Reaction self) -> unsigned int


        Returns the number of reactant species in this Reaction.

        Returns the number of reactants in this Reaction.

        """
        return _libsbml.Reaction_getNumReactants(self)


    def getNumProducts(self):
        """
        getNumProducts(Reaction self) -> unsigned int


        Returns the number of product species in this Reaction.

        Returns the number of products in this Reaction.

        """
        return _libsbml.Reaction_getNumProducts(self)


    def getNumModifiers(self):
        """
        getNumModifiers(Reaction self) -> unsigned int


        Returns the number of modifier species in this Reaction.

        Returns the number of modifiers in this Reaction.

        """
        return _libsbml.Reaction_getNumModifiers(self)


    def removeReactant(self, *args):
        """
        removeReactant(Reaction self, unsigned int n) -> SpeciesReference
        removeReactant(Reaction self, string species) -> SpeciesReference


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeReactant(string species)

        Removes the reactant species (SpeciesReference object) having the
        given   'species' attribute in this Reaction and returns a pointer to
        it.

        The caller owns the returned object and is responsible for deleting
        it.

        Parameter 'species' is the 'species' attribute of the reactant
        SpeciesReference  object.

        Returns the removed reactant SpeciesReference object, or 'None' if no
        reactant SpeciesReference object with the given 'species' attribute
        'species' exists in this Reaction.

        ______________________________________________________________________
        Method variant with the following signature:

            removeReactant(long n)

        Removes the nth reactant species (SpeciesReference object) in the list
        of  reactants in this Reaction and returns a pointer to it.

        The caller owns the returned object and is responsible for deleting
        it. The caller should first call getNumReactants() to find out how
        many reactants there are, to avoid using an invalid index number.

        Parameter 'n' is the index of the reactant SpeciesReference object to
        remove.

        Returns the removed reactant SpeciesReference object, or 'None' if the
        given index is out of range.

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


    def removeProduct(self, *args):
        """
        removeProduct(Reaction self, unsigned int n) -> SpeciesReference
        removeProduct(Reaction self, string species) -> SpeciesReference


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeProduct(string species)

        Removes the product species (SpeciesReference object) having the given
        'species' attribute in this Reaction and returns a pointer to it.

        The caller owns the returned object and is responsible for deleting
        it.

        Parameter 'species' is the 'species' attribute of the product
        SpeciesReference  object.

        Returns the removed product SpeciesReference object, or 'None' if no
        product SpeciesReference object with the given 'species' attribute
        'species' exists in this Reaction.

        ______________________________________________________________________
        Method variant with the following signature:

            removeProduct(long n)

        Removes the nth product species (SpeciesReference object) in the list
        of  products in this Reaction and returns a pointer to it.

        The caller owns the returned object and is responsible for deleting
        it. The caller should first call getNumProducts() to find out how many
        products there are, to avoid using an invalid index number.

        Parameter 'n' is the index of the product SpeciesReference object to
        remove.

        Returns the removed product SpeciesReference object, or 'None' if the
        given index is out of range.

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


    def removeModifier(self, *args):
        """
        removeModifier(Reaction self, unsigned int n) -> ModifierSpeciesReference
        removeModifier(Reaction self, string species) -> ModifierSpeciesReference


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeModifier(string species)

        Removes the modifier species (ModifierSpeciesReference object) having
        the given 'species' attribute in this Reaction and returns a pointer
        to it.

        The caller owns the returned object and is responsible for deleting
        it.

        Parameter 'species' is the 'species' attribute of the
        ModifierSpeciesReference  object.

        Returns the removed ModifierSpeciesReference object, or 'None' if no
        ModifierSpeciesReference object with the given 'species' attribute
        'species' exists in this Reaction.

        ______________________________________________________________________
        Method variant with the following signature:

            removeModifier(long n)

        Removes the nth modifier species (ModifierSpeciesReference object) in
        the list of  modifiers in this Reaction and returns a pointer to it.

        The caller owns the returned object and is responsible for deleting
        it. The caller should first call getNumModifiers() to find out how
        many modifiers there are, to avoid using an invalid index number.

        Parameter 'n' is the index of the ModifierSpeciesReference object to
        remove.

        Returns the removed ModifierSpeciesReference object, or 'None' if the
        given index is out of range.

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


    def connectToChild(self):
        """connectToChild(Reaction self)"""
        return _libsbml.Reaction_connectToChild(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(Reaction self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.Reaction_enablePackageInternal(self, pkgURI, pkgPrefix, flag)


    def updateSBMLNamespace(self, package, level, version):
        """
        updateSBMLNamespace(Reaction self, string package, unsigned int level, unsigned int version)


        Internal implementation method.

        """
        return _libsbml.Reaction_updateSBMLNamespace(self, package, level, version)


    def getTypeCode(self):
        """
        getTypeCode(Reaction self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_REACTION (default).

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.Reaction_getTypeCode(self)


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


        Returns the XML element name of this object, which for Reaction, is
        always ''reaction'.'

        Returns the name of this element, i.e., ''reaction'.'

        """
        return _libsbml.Reaction_getElementName(self)


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


        Predicate returning 'True' if all the required attributes for this
        Reaction object have been set.

        The required attributes for a Reaction object are:

        * 'id' (or 'name' in SBML Level 1)

        * 'fast' (in Level 3 Version 1 only, where it is defined as a
        required attribute)

        * 'reversible' (in Level 3 only, where it is defined as a required
        attribute)

        Returns 'True' if the required attributes have been set, 'False'
        otherwise.

        """
        return _libsbml.Reaction_hasRequiredAttributes(self)

Reaction_swigregister = _libsbml.Reaction_swigregister
Reaction_swigregister(Reaction)

class ListOfReactions(ListOf):
    """

    A list of Reaction objects.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfReactions, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfReactions, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ListOfReactions self, unsigned int level, unsigned int version) -> ListOfReactions
        __init__(ListOfReactions self, SBMLNamespaces sbmlns) -> ListOfReactions


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfReactions(SBMLNamespaces sbmlns)

        Creates a new ListOfReactions object.

        The object is constructed such that it is valid for the SBML Level and
        Version combination determined by the SBMLNamespaces object in
        'sbmlns'.

        Parameter 'sbmlns' is an SBMLNamespaces object that is used to
        determine the characteristics of the ListOfReactions object to be
        created.

        Throws SBMLConstructorException: Thrown if the given 'sbmlns' is
        inconsistent or incompatible with this object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfReactions(long level, long version)

        Creates a new ListOfReactions object.

        The object is constructed such that it is valid for the given SBML
        Level and Version combination.

        Parameter 'level' is the SBML Level.

        Parameter 'version' is the Version within the SBML Level.

        Throws SBMLConstructorException: Thrown if the given 'level' and
        'version' combination are invalid or if this object is incompatible
        with the given level and version.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        """
        this = _libsbml.new_ListOfReactions(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ListOfReactions self) -> ListOfReactions


        Creates and returns a deep copy of this ListOfReactions object.

        Returns the (deep) copy of this ListOfReactions object.

        """
        return _libsbml.ListOfReactions_clone(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfReactions self) -> int


        Returns the libSBML type code for the objects contained in this ListOf
        (i.e., Reaction objects, if the list is non-empty).

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for objects contained in this list:
        SBML_REACTION (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfReactions_getItemTypeCode(self)


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


        Returns the XML element name of this object

        For ListOfReactions, the XML element name is ''listOfReactions'.'

        Returns the name of this element, i.e., ''listOfReactions'.'

        """
        return _libsbml.ListOfReactions_getElementName(self)


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a Reaction from the ListOfReactions.

        Parameter 'n' is the index number of the Reaction to get.

        Returns the nth Reaction in this ListOfReactions. If the index 'n' is
        invalid, 'None' is returned.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a Reaction from the ListOfReactions based on its identifier.

        Parameter 'sid' is a string representing the identifier of the
        Reaction to get.

        Returns Reaction in this ListOfReactions with the given 'sid' or
        'None' if no such Reaction exists.

        See also get(), size().

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


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth item from this ListOfReactions items and returns a
        pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the item to remove.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes item in this ListOfReactions 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 'sid', then None
        is returned.

        Parameter 'sid' is the identifier of the item to remove.

        Returns the item removed.  As mentioned above, the caller owns the
        returned item.

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

    __swig_destroy__ = _libsbml.delete_ListOfReactions
    __del__ = lambda self: None
ListOfReactions_swigregister = _libsbml.ListOfReactions_swigregister
ListOfReactions_swigregister(ListOfReactions)

class KineticLaw(SBase):
    """

    The rate expression for an SBML reaction.

    An object of class KineticLaw is used to describe the rate at which
    the process defined by a given Reaction takes place.  KineticLaw has
    subelements called 'math' (for MathML content) and 'listOfParameters'
    (of class ListOfParameters), in addition to the attributes and
    subelements it inherits from SBase.

    KineticLaw's 'math' subelement for holding a MathML formula (required
    through SBML Level 3 Version 1, but optional as of SBML  Level 3
    Version 2) defines the rate of the reaction.  The formula may refer to
    other entities in a model as well as local parameter definitions
    within the scope of the Reaction (see below).  It is important to keep
    in mind, however, that the only Species identifiers that can be used
    in this formula are those declared in the lists of reactants, products
    and modifiers in the Reaction structure.  (In other words, before a
    species can be referenced in the KineticLaw, it must be declared in
    one of those lists.)

    KineticLaw provides a way to define local parameters whose identifiers
    can be used in the 'math' formula of that KineticLaw instance.  Prior
    to SBML Level 3, these parameter definitions are stored inside a
    'listOfParameters' subelement containing Parameter objects; in SBML
    Level 3, this is achieved using a specialized object class called
    LocalParameter and the containing subelement is called
    'listOfLocalParameters'.  In both cases, the parameters so defined are
    only visible within the KineticLaw (or, as of SBML Level 3 Version 2,
    only visible within the parent Reaction);  they cannot be accessed
    outside.  A local parameter within one reaction is not visible from
    within another reaction, nor is it visible to any other construct
    outside of the KineticLaw in which it is defined.  In addition,
    another important feature is that if such a Parameter (or in Level 3,
    LocalParameter) object has the same identifier as another object in
    the scope of the enclosing Model, the definition inside the KineticLaw
    takes precedence.  In other words, within the KineticLaw's 'math'
    formula, references to local parameter identifiers shadow any
    identical global identifiers.

    The values of local parameters defined within KineticLaw objects
    cannot change.  In SBML Level 3, this quality is built into the
    LocalParameter construct.  In Level 2, where the same kind of
    Parameter object class is used as for global parameters, the Parameter
    objects' 'constant' attribute must always have a value of 'True'
    (either explicitly or left to its default value).

    A warning about identifier shadowing
    ======================================================================

    A common misconception is that different classes of objects (e.g.,
    species, compartments, parameters) in SBML have different identifier
    scopes.  They do not.  The implication is that if a KineticLaw's local
    parameter definition uses an identifier identical to any other
    identifier defined in the model outside the KineticLaw, even if the
    other identifier does not belong to a parameter type of object, the
    local parameter's identifier takes precedence within that KineticLaw's
    'math' formula.  It is not an error in SBML for identifiers to shadow
    each other this way, but can lead to confusing and subtle errors.

    SBML Level/Version differences
    ======================================================================

    In SBML Level 2 Version 1, the SBML specification included two
    additional attributes on KineticLaw called 'substanceUnits' and
    'timeUnits'.  They were removed beginning with SBML Level 2 Version 2
    because further research determined they introduced many problems.
    The most significant problem was that their use could easily lead to
    the creation of valid models whose reactions nevertheless could not be
    integrated into a system of equations without outside knowledge for
    converting the quantities used.  Examination of real-life models
    revealed that a common reason for using 'substanceUnits' on KineticLaw
    was to set the units of all reactions to the same set of substance
    units, something that is better achieved by using UnitDefinition to
    redefine ''substance'' for the whole Model.

    As mentioned above, in SBML Level 2 Versions 2-4, local parameters are
    of class Parameter.  In SBML Level 3, the class of object is
    LocalParameter.

    In SBML Level 3 Version 2, the scope of the LocalParameter was
    expanded to the entire Reaction, instead of just the KineticLaw.
    This introduced a single new restriction: an L3v2 LocalParameter may
    not now shadow the 'id' of any Species referenced by a
    SpeciesReference in the same Reaction.  Other than that, there is no
    difference in any  core construct.  However, packages may take
    advantage of this new scope by  adding elements to the Reaction that
    may now reference a LocalParameter  defined in the same Reaction.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, KineticLaw, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, KineticLaw, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_KineticLaw
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(KineticLaw self, unsigned int level, unsigned int version) -> KineticLaw
        __init__(KineticLaw self, SBMLNamespaces sbmlns) -> KineticLaw
        __init__(KineticLaw self, KineticLaw orig) -> KineticLaw


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            KineticLaw(SBMLNamespaces sbmlns)

        Creates a new KineticLaw using the given SBMLNamespaces object
        'sbmlns'.

        The SBMLNamespaces object encapsulates SBML Level/Version/namespaces
        information.  It is used to communicate the SBML Level, Version, and
        (in Level 3) packages used in addition to SBML Level 3 Core.  A common
        approach to using libSBML's SBMLNamespaces facilities is to create an
        SBMLNamespaces object somewhere in a program once, then hand that
        object as needed to object constructors that accept SBMLNamespaces as
        arguments.

        Parameter 'sbmlns' is an SBMLNamespaces object.

        Throws SBMLConstructorException: Thrown if the given 'sbmlns' is
        inconsistent or incompatible with this object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            KineticLaw(long level, long version)

        Creates a new KineticLaw using the given SBML 'level' and 'version'
        values.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        KineticLaw.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this KineticLaw.

        Throws SBMLConstructorException: Thrown if the given 'level' and
        'version' combination are invalid or if this object is incompatible
        with the given level and version.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            KineticLaw(KineticLaw orig)

        Copy constructor; creates a copy of this KineticLaw.

        Parameter 'orig' is the object to copy.

        """
        this = _libsbml.new_KineticLaw(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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


        Creates and returns a deep copy of this KineticLaw object.

        Returns the (deep) copy of this KineticLaw object.

        """
        return _libsbml.KineticLaw_clone(self)


    def getElementBySId(self, id):
        """
        getElementBySId(KineticLaw self, string id) -> SBase


        Returns the first child element found that has the given 'id' in the
        model-wide SId namespace, or 'None' if no such object is found.

        Parameter 'id' is string representing the id of the object to find.

        Returns pointer to the first element found with the given 'id'.

        """
        return _libsbml.KineticLaw_getElementBySId(self, id)


    def getElementByMetaId(self, metaid):
        """
        getElementByMetaId(KineticLaw self, string metaid) -> SBase


        Returns the first child element it can find with the given 'metaid',
        or 'None' if no such object is found.

        Parameter 'metaid' is string representing the metaid of the object to
        find.

        Returns pointer to the first element found with the given 'metaid'.

        """
        return _libsbml.KineticLaw_getElementByMetaId(self, metaid)


    def getFormula(self):
        """
        getFormula(KineticLaw self) -> string


        Returns the mathematical formula for this KineticLaw object and return
        it as as a text string.

        This is fundamentally equivalent to getMath(). This variant is
        provided principally for compatibility compatibility with SBML Level
        1.

        Returns a string representing the formula of this KineticLaw.

        Note: SBML Level 1 uses a text-string format for mathematical
        formulas. SBML Level 2 uses MathML, an XML format for representing
        mathematical expressions.  LibSBML provides an Abstract Syntax Tree
        API for working with mathematical expressions; this API is more
        powerful than working with formulas directly in text form, and ASTs
        can be translated into either MathML or the text-string syntax.  The
        libSBML methods that accept text-string formulas directly (such as
        this constructor) are provided for SBML Level 1 compatibility, but
        developers are encouraged to use the AST mechanisms.

        See also getMath().

        """
        return _libsbml.KineticLaw_getFormula(self)


    def getMath(self):
        """
        getMath(KineticLaw self) -> ASTNode


        Returns the mathematical formula for this KineticLaw object and return
        it as as an AST.

        This is fundamentally equivalent to getFormula(). The latter is
        provided principally for compatibility compatibility with SBML Level
        1, which represented mathematical formulas in text-string form.

        Returns the ASTNode representation of the mathematical formula,  or
        'None' if the math is not set.

        See also getFormula().

        """
        return _libsbml.KineticLaw_getMath(self)


    def getTimeUnits(self):
        """
        getTimeUnits(KineticLaw self) -> string


        (SBML Level 2 Version 1 only) Returns the value of the 'timeUnits'
        attribute of this KineticLaw object.

        Returns the 'timeUnits' attribute value.

        Note: The attributes 'timeUnits' and 'substanceUnits' are present only
        in SBML Level 2 Version 1.  In SBML Level 2 Version 2, the 'timeUnits'
        and 'substanceUnits' attributes were removed.  For compatibility with
        new versions of SBML, users are cautioned to avoid these attributes.

        """
        return _libsbml.KineticLaw_getTimeUnits(self)


    def getSubstanceUnits(self):
        """
        getSubstanceUnits(KineticLaw self) -> string


        (SBML Level 2 Version 1 only) Returns the value of the
        'substanceUnits' attribute of this KineticLaw object.

        Returns the 'substanceUnits' attribute value.

        Note: The attributes 'timeUnits' and 'substanceUnits' are present only
        in SBML Level 2 Version 1.  In SBML Level 2 Version 2, the 'timeUnits'
        and 'substanceUnits' attributes were removed.  For compatibility with
        new versions of SBML, users are cautioned to avoid these attributes.

        """
        return _libsbml.KineticLaw_getSubstanceUnits(self)


    def isSetFormula(self):
        """
        isSetFormula(KineticLaw self) -> bool


        Predicate returning 'True' if this KineticLaw's 'formula' attribute is
        set.

        This is functionally identical to the method isSetMath().  It is
        provided in order to mirror the parallel between getFormula() and
        getMath().

        Returns 'True' if the formula (meaning the 'math' subelement) of this
        KineticLaw is set, 'False' otherwise.

        Note: SBML Level 1 uses a text-string format for mathematical
        formulas. SBML Level 2 uses MathML, an XML format for representing
        mathematical expressions.  LibSBML provides an Abstract Syntax Tree
        API for working with mathematical expressions; this API is more
        powerful than working with formulas directly in text form, and ASTs
        can be translated into either MathML or the text-string syntax.  The
        libSBML methods that accept text-string formulas directly (such as
        this constructor) are provided for SBML Level 1 compatibility, but
        developers are encouraged to use the AST mechanisms.

        See also isSetMath().

        """
        return _libsbml.KineticLaw_isSetFormula(self)


    def isSetMath(self):
        """
        isSetMath(KineticLaw self) -> bool


        Predicate returning 'True' if this Kinetic's 'math' subelement is set.

        This is identical to the method isSetFormula(). It is provided in
        order to mirror the parallel between getFormula() and getMath().

        Returns 'True' if the formula (meaning the 'math' subelement) of this
        KineticLaw is set, 'False' otherwise.

        See also isSetFormula().

        """
        return _libsbml.KineticLaw_isSetMath(self)


    def isSetTimeUnits(self):
        """
        isSetTimeUnits(KineticLaw self) -> bool


        (SBML Level 2 Version 1 only) Predicate returning 'True' if this
        SpeciesReference's 'timeUnits' attribute is set.

        Returns 'True' if the 'timeUnits' attribute of this KineticLaw object
        is set, 'False' otherwise.

        Note: The attributes 'timeUnits' and 'substanceUnits' are present only
        in SBML Level 2 Version 1.  In SBML Level 2 Version 2, the 'timeUnits'
        and 'substanceUnits' attributes were removed.  For compatibility with
        new versions of SBML, users are cautioned to avoid these attributes.

        """
        return _libsbml.KineticLaw_isSetTimeUnits(self)


    def isSetSubstanceUnits(self):
        """
        isSetSubstanceUnits(KineticLaw self) -> bool


        (SBML Level 2 Version 1 only) Predicate returning 'True' if this
        SpeciesReference's 'substanceUnits' attribute is set.

        Returns 'True' if the 'substanceUnits' attribute of this KineticLaw
        object is set, 'False' otherwise.

        Note: The attributes 'timeUnits' and 'substanceUnits' are present only
        in SBML Level 2 Version 1.  In SBML Level 2 Version 2, the 'timeUnits'
        and 'substanceUnits' attributes were removed.  For compatibility with
        new versions of SBML, users are cautioned to avoid these attributes.

        """
        return _libsbml.KineticLaw_isSetSubstanceUnits(self)


    def setFormula(self, formula):
        """
        setFormula(KineticLaw self, string formula) -> int


        Sets the mathematical expression of this KineticLaw instance to the
        given 'formula'.

        The given 'formula' string is copied.  Internally, libSBML stores the
        mathematical expression as an ASTNode.

        Parameter 'formula' is the mathematical expression to use, represented
        in text-string form.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_OBJECT

        Note: SBML Level 1 uses a text-string format for mathematical
        formulas. SBML Level 2 uses MathML, an XML format for representing
        mathematical expressions.  LibSBML provides an Abstract Syntax Tree
        API for working with mathematical expressions; this API is more
        powerful than working with formulas directly in text form, and ASTs
        can be translated into either MathML or the text-string syntax.  The
        libSBML methods that accept text-string formulas directly (such as
        this constructor) are provided for SBML Level 1 compatibility, but
        developers are encouraged to use the AST mechanisms.

        See also setMath().

        """
        return _libsbml.KineticLaw_setFormula(self, formula)


    def setMath(self, math):
        """
        setMath(KineticLaw self, ASTNode math) -> int


        Sets the mathematical expression of this KineticLaw instance to a copy
        of the given ASTNode.

        This is fundamentally identical to getFormula(). The latter is
        provided principally for compatibility compatibility with SBML Level
        1, which represented mathematical formulas in text-string form.

        Parameter 'math' is an ASTNode representing a formula tree.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_OBJECT

        See also setFormula().

        """
        return _libsbml.KineticLaw_setMath(self, math)


    def setTimeUnits(self, sid):
        """
        setTimeUnits(KineticLaw self, string sid) -> int


        (SBML Level 2 Version 1 only) Sets the 'timeUnits' attribute of this
        KineticLaw object to a copy of the identifier in 'sid'.

        Parameter 'sid' is the identifier of the units to use.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        Note: The attributes 'timeUnits' and 'substanceUnits' are present only
        in SBML Level 2 Version 1.  In SBML Level 2 Version 2, the 'timeUnits'
        and 'substanceUnits' attributes were removed.  For compatibility with
        new versions of SBML, users are cautioned to avoid these attributes.

        """
        return _libsbml.KineticLaw_setTimeUnits(self, sid)


    def setSubstanceUnits(self, sid):
        """
        setSubstanceUnits(KineticLaw self, string sid) -> int


        (SBML Level 2 Version 1 only) Sets the 'substanceUnits' attribute of
        this KineticLaw object to a copy of the identifier given in 'sid'.

        Parameter 'sid' is the identifier of the units to use.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        Note: The attributes 'timeUnits' and 'substanceUnits' are present only
        in SBML Level 2 Version 1.  In SBML Level 2 Version 2, the 'timeUnits'
        and 'substanceUnits' attributes were removed.  For compatibility with
        new versions of SBML, users are cautioned to avoid these attributes.

        """
        return _libsbml.KineticLaw_setSubstanceUnits(self, sid)


    def unsetTimeUnits(self):
        """
        unsetTimeUnits(KineticLaw self) -> int


        (SBML Level 2 Version 1 only) Unsets the 'timeUnits' attribugte of
        this KineticLaw object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        Note: The attributes 'timeUnits' and 'substanceUnits' are present only
        in SBML Level 2 Version 1.  In SBML Level 2 Version 2, the 'timeUnits'
        and 'substanceUnits' attributes were removed.  For compatibility with
        new versions of SBML, users are cautioned to avoid these attributes.

        """
        return _libsbml.KineticLaw_unsetTimeUnits(self)


    def unsetSubstanceUnits(self):
        """
        unsetSubstanceUnits(KineticLaw self) -> int


        (SBML Level 2 Version 1 only) Unsets the 'substanceUnits' attribute of
        this KineticLaw object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        Note: The attributes 'timeUnits' and 'substanceUnits' are present only
        in SBML Level 2 Version 1.  In SBML Level 2 Version 2, the 'timeUnits'
        and 'substanceUnits' attributes were removed.  For compatibility with
        new versions of SBML, users are cautioned to avoid these attributes.

        """
        return _libsbml.KineticLaw_unsetSubstanceUnits(self)


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


        Adds a copy of the given Parameter object to the list of local
        parameters in this KineticLaw.

        This function should be used for SBML Level 1 and Level 2 documents,
        as the equivalent constructs in Level 3 are LocalParameter objects
        instead.

        Parameter 'p' is the Parameter to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_DUPLICATE_OBJECT_ID

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_OPERATION_FAILED

        Note: This method should be used with some caution.  The fact that
        this method copies the object passed to it means that the caller will
        be left holding a physically different object instance than the one
        contained inside this object.  Changes made to the original object
        instance (such as resetting attribute values) will not affect the
        instance in this object.  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 other methods on this class
        (particularly a corresponding method whose name begins with the word
        create) for alternatives that do not lead to these issues.

        See also createParameter().

        """
        return _libsbml.KineticLaw_addParameter(self, p)


    def addLocalParameter(self, p):
        """
        addLocalParameter(KineticLaw self, LocalParameter p) -> int


        Adds a copy of the given LocalParameter object to the list of local
        parameters in this KineticLaw.

        This function should be used for SBML Level 3 documents, as the
        equivalent  constructs in Level 2 and Level 1 are Parameter objects
        instead.

        Parameter 'p' is the LocalParameter to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_DUPLICATE_OBJECT_ID

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_OPERATION_FAILED

        Note: This method should be used with some caution.  The fact that
        this method copies the object passed to it means that the caller will
        be left holding a physically different object instance than the one
        contained inside this object.  Changes made to the original object
        instance (such as resetting attribute values) will not affect the
        instance in this object.  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 other methods on this class
        (particularly a corresponding method whose name begins with the word
        create) for alternatives that do not lead to these issues.

        See also createLocalParameter().

        """
        return _libsbml.KineticLaw_addLocalParameter(self, p)


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


        Creates a new Parameter object, adds it to this KineticLaw's list of
        parameters, and returns the Parameter object created.

        This function should be used for SBML Level 1 and Level 2 documents,
        as the equivalent constructs in Level 3 are LocalParameter objects
        instead.

        Returns a new Parameter object instance.

        See also addParameter().

        """
        return _libsbml.KineticLaw_createParameter(self)


    def createLocalParameter(self):
        """
        createLocalParameter(KineticLaw self) -> LocalParameter


        Creates a new LocalParameter object, adds it to this KineticLaw's list
        of local parameters, and returns the LocalParameter object created.

        This function should be used for SBML Level 3 documents, as the
        equivalent  constructs in Level 2 and Level 1 are Parameter objects
        instead.

        Returns a new LocalParameter object instance.

        See also addLocalParameter().

        """
        return _libsbml.KineticLaw_createLocalParameter(self)


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


        Returns the list of parameters in this KineticLaw object.

        This function should be used for SBML Level 1 and Level 2 documents,
        as the equivalent constructs in Level 3 are LocalParameter objects
        instead.

        Returns the list of Parameters for this KineticLaw.

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


    def getListOfLocalParameters(self, *args):
        """
        getListOfLocalParameters(KineticLaw self) -> ListOfLocalParameters
        getListOfLocalParameters(KineticLaw self) -> ListOfLocalParameters


        Returns the list of local parameters in this KineticLaw object.

        This function should be used for SBML Level 3 documents, as the
        equivalent  constructs in Level 2 and Level 1 are Parameter objects
        instead.

        Returns the list of LocalParameters for this KineticLaw.

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


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getParameter(long n)

        Returns the nth Parameter object in the list of parameters in this
        KineticLaw instance.

        This function should be used for SBML Level 1 and Level 2 documents,
        as the equivalent constructs in Level 3 are LocalParameter objects
        instead.

        Parameter 'n' is the index of the Parameter object sought.

        Returns the nth Parameter of this KineticLaw. If the index 'n' is
        invalid, 'None' is returned.

        ______________________________________________________________________
        Method variant with the following signature:

            getParameter(string sid)

        Returns a parameter based on its identifier.

        This function should be used for SBML Level 1 and Level 2 documents,
        as the equivalent constructs in Level 3 are LocalParameter objects
        instead.

        Parameter 'sid' is the identifier of the Parameter being sought.

        Returns the Parameter object in this KineticLaw instace having the
        given 'id', or 'None' if no such Parameter exists.

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


    def getLocalParameter(self, *args):
        """
        getLocalParameter(KineticLaw self, unsigned int n) -> LocalParameter
        getLocalParameter(KineticLaw self, unsigned int n) -> LocalParameter
        getLocalParameter(KineticLaw self, string sid) -> LocalParameter
        getLocalParameter(KineticLaw self, string sid) -> LocalParameter


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getLocalParameter(long n)

        Returns the nth LocalParameter object in the list of local parameters
        in this KineticLaw instance.

        This function should be used for SBML Level 3 documents, as the
        equivalent  constructs in Level 2 and Level 1 are Parameter objects
        instead.

        Parameter 'n' is the index of the LocalParameter object sought.

        Returns the nth LocalParameter of this KineticLaw. If the index 'n' is
        invalid, 'None' is returned.

        ______________________________________________________________________
        Method variant with the following signature:

            getLocalParameter(string sid)

        Returns a local parameter based on its identifier.

        This function should be used for SBML Level 3 documents, as the
        equivalent  constructs in Level 2 and Level 1 are Parameter objects
        instead.

        Parameter 'sid' is the identifier of the LocalParameter being sought.

        Returns the LocalParameter object in this KineticLaw instace having
        the given 'id', or 'None' if no such LocalParameter exists.

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


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


        Returns the number of parameters in this KineticLaw instance.

        This function should be used for SBML Level 1 and Level 2 documents,
        as the equivalent constructs in Level 3 are LocalParameter objects
        instead.

        Returns the number of Parameters in this KineticLaw.

        """
        return _libsbml.KineticLaw_getNumParameters(self)


    def getNumLocalParameters(self):
        """
        getNumLocalParameters(KineticLaw self) -> unsigned int


        Returns the number of local parameters in this KineticLaw instance.

        This function should be used for SBML Level 3 documents, as the
        equivalent  constructs in Level 2 and Level 1 are Parameter objects
        instead.

        Returns the number of LocalParameters in this KineticLaw.

        """
        return _libsbml.KineticLaw_getNumLocalParameters(self)


    def getDerivedUnitDefinition(self, *args):
        """
        getDerivedUnitDefinition(KineticLaw self) -> UnitDefinition
        getDerivedUnitDefinition(KineticLaw self) -> UnitDefinition


        Calculates and returns a UnitDefinition that expresses the units of
        measurement assumed for the 'math' expression of this KineticLaw.

        The units are calculated based on the mathematical expression in the
        KineticLaw and the model quantities referenced by <ci> elements used
        within that expression.  The getDerivedUnitDefinition() method returns
        the calculated units.

        Note: The functionality that facilitates unit analysis depends on the
        model as a whole.  Thus, in cases where the object has not been added
        to a model or the model itself is incomplete, unit analysis is not
        possible and this method will return 'None.'

        WARNING:

        Note that it is possible the 'math' expression in the KineticLaw
        contains pure numbers or parameters with undeclared units.  In those
        cases, it is not possible to calculate the units of the overall
        expression without making assumptions.  LibSBML does not make
        assumptions about the units, and KineticLaw.getDerivedUnitDefinition()
        returns the units as far as it is able to determine them.  For
        example, in an expression X + Y, if X has unambiguously-defined units
        and Y does not, it will return the units of X.  It is important that
        callers also invoke the method KineticLaw.containsUndeclaredUnits()to
        determine whether this situation holds.  Callers may wish to take
        suitable actions in those scenarios.

        Returns a UnitDefinition that expresses the units of the math
        expression of this KineticLaw, or 'None' if one cannot be constructed.

        See also containsUndeclaredUnits().

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


    def containsUndeclaredUnits(self, *args):
        """
        containsUndeclaredUnits(KineticLaw self) -> bool
        containsUndeclaredUnits(KineticLaw self) -> bool


        Predicate returning 'True' if the math expression of this KineticLaw
        contains parameters/numbers with undeclared units.

        Returns 'True' if the math expression of this KineticLaw includes
        parameters/numbers  with undeclared units, 'False' otherwise.

        Note: A return value of 'True' indicates that the UnitDefinition
        returned by getDerivedUnitDefinition() may not accurately represent
        the units of the expression.

        See also getDerivedUnitDefinition().

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


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeParameter(long n)

        Removes the nth Parameter object in the list of parameters  in this
        KineticLaw instance and returns a pointer to it.

        This function should be used for SBML Level 1 and Level 2 documents,
        as the equivalent constructs in Level 3 are LocalParameter objects
        instead.

        The caller owns the returned object and is responsible for deleting
        it.

        Parameter 'n' is the index of the Parameter object to remove.

        Returns the Parameter object removed.  As mentioned above,  the caller
        owns the returned item. 'None' is returned if the given index  is out
        of range.

        ______________________________________________________________________
        Method variant with the following signature:

            removeParameter(string sid)

        Removes a Parameter object with the given identifier in the list of
        parameters in this KineticLaw instance and returns a pointer to it.

        This function should be used for SBML Level 1 and Level 2 documents,
        as the equivalent constructs in Level 3 are LocalParameter objects
        instead.

        The caller owns the returned object and is responsible for deleting
        it.

        Parameter 'sid' is the identifier of the Parameter to remove.

        Returns the Parameter object removed.  As mentioned above, the  caller
        owns the returned object. 'None' is returned if no Parameter object
        with the identifier exists in this KineticLaw instance.

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


    def removeLocalParameter(self, *args):
        """
        removeLocalParameter(KineticLaw self, unsigned int n) -> LocalParameter
        removeLocalParameter(KineticLaw self, string sid) -> LocalParameter


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeLocalParameter(long n)

        Removes the nth LocalParameter object in the list of local parameters
        in this KineticLaw instance and returns a pointer to it.

        This function should be used for SBML Level 3 documents, as the
        equivalent  constructs in Level 2 and Level 1 are Parameter objects
        instead.

        The caller owns the returned object and is responsible for deleting
        it.

        Parameter 'n' is the index of the LocalParameter object to remove.

        Returns the LocalParameter object removed.  As mentioned above,  the
        caller owns the returned item. 'None' is returned if the given index
        is out of range.

        ______________________________________________________________________
        Method variant with the following signature:

            removeLocalParameter(string sid)

        Removes a LocalParameter object with the given identifier in the list
        of local parameters in this KineticLaw instance and returns a pointer
        to it.

        This function should be used for SBML Level 3 documents, as the
        equivalent  constructs in Level 2 and Level 1 are Parameter objects
        instead.

        The caller owns the returned object and is responsible for deleting
        it.

        Parameter 'sid' is the identifier of the LocalParameter to remove.

        Returns the LocalParameter object removed.  As mentioned above, the
        caller owns the returned object. 'None' is returned if no
        LocalParameter object with the identifier exists in this KineticLaw
        instance.

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


    def connectToChild(self):
        """connectToChild(KineticLaw self)"""
        return _libsbml.KineticLaw_connectToChild(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(KineticLaw self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.KineticLaw_enablePackageInternal(self, pkgURI, pkgPrefix, flag)


    def updateSBMLNamespace(self, package, level, version):
        """
        updateSBMLNamespace(KineticLaw self, string package, unsigned int level, unsigned int version)


        Internal implementation method.

        """
        return _libsbml.KineticLaw_updateSBMLNamespace(self, package, level, version)


    def getTypeCode(self):
        """
        getTypeCode(KineticLaw self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_KINETIC_LAW
        (default).

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.KineticLaw_getTypeCode(self)


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


        Returns the XML element name of this object, which for Species, is
        always ''kineticLaw'.'

        Returns the name of this element, i.e., ''kineticLaw'.'

        """
        return _libsbml.KineticLaw_getElementName(self)


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


        Predicate returning 'True' if all the required attributes for this
        KineticLaw object have been set.

        The required attributes for a KineticLaw object are:

        * 'formula' (SBML Level 1 only)

        Returns 'True' if the required attributes have been set, 'False'
        otherwise.

        """
        return _libsbml.KineticLaw_hasRequiredAttributes(self)


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


        Predicate returning 'True' if all the required elements for this
        KineticLaw object have been set.

        Note: The required elements for a KineticLaw object are:

        * 'math' inSBML Level 2 and Level 3 Version 1.   (In SBML Level 3
        Version 2+, it is no longer required.)

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

        """
        return _libsbml.KineticLaw_hasRequiredElements(self)


    def removeFromParentAndDelete(self):
        """
        removeFromParentAndDelete(KineticLaw self) -> int


        Finds this KineticLaw's Reaction parent and calls unsetKineticLaw() on
        it, indirectly deleting itself.

        Overridden from the SBase function since the parent is not a ListOf.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.KineticLaw_removeFromParentAndDelete(self)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(KineticLaw self, string oldid, string newid)


        Replaces all uses of a given 'SIdRef' type attribute value with
        another value.

        In SBML, object identifiers are of a data type called SId. In SBML
        Level 3, an explicit data type called SIdRef was introduced for
        attribute values that refer to SId values; in previous Levels of SBML,
        this data type did not exist and attributes were simply described to
        as 'referring to an identifier', but the effective data type was the
        same as SIdRef in Level 3.  These and other methods of libSBML refer
        to the type SIdRef for all Levels of SBML, even if the corresponding
        SBML specification did not explicitly name the data type.

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas in MathML content, comparing the referenced
        identifiers to the value of 'oldid'.  If any matches are found, the
        matching values are replaced with 'newid'.  The method does not
        descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.KineticLaw_renameSIdRefs(self, oldid, newid)


    def renameUnitSIdRefs(self, oldid, newid):
        """
        renameUnitSIdRefs(KineticLaw self, string oldid, string newid)


        Replaces all uses of a given 'UnitSIdRef' type attribute value with
        another value.

        In SBML, unit definitions have identifiers of type UnitSId.  In SBML
        Level 3, an explicit data type called UnitSIdRef was introduced for
        attribute values that refer to UnitSId values; in previous Levels of
        SBML, this data type did not exist and attributes were simply
        described to as 'referring to a unit identifier', but the effective
        data type was the same as UnitSIdRef in Level 3.  These and other
        methods of libSBML refer to the type UnitSIdRef for all Levels of
        SBML, even if the corresponding SBML specification did not explicitly
        name the data type.

        This method works by looking at all unit identifier attribute values
        (including, if appropriate, inside mathematical formulas), comparing
        the referenced unit identifiers to the value of 'oldid'.  If any
        matches are found, the matching values are replaced with 'newid'.  The
        method does not descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.KineticLaw_renameUnitSIdRefs(self, oldid, newid)


    def replaceSIDWithFunction(self, id, function):
        """
        replaceSIDWithFunction(KineticLaw self, string id, ASTNode function)


        Internal implementation method.

        """
        return _libsbml.KineticLaw_replaceSIDWithFunction(self, id, function)


    def divideAssignmentsToSIdByFunction(self, id, function):
        """
        divideAssignmentsToSIdByFunction(KineticLaw self, string id, ASTNode function)


        Internal implementation method.

        """
        return _libsbml.KineticLaw_divideAssignmentsToSIdByFunction(self, id, function)


    def multiplyAssignmentsToSIdByFunction(self, id, function):
        """
        multiplyAssignmentsToSIdByFunction(KineticLaw self, string id, ASTNode function)


        Internal implementation method.

        """
        return _libsbml.KineticLaw_multiplyAssignmentsToSIdByFunction(self, id, function)

KineticLaw_swigregister = _libsbml.KineticLaw_swigregister
KineticLaw_swigregister(KineticLaw)

class SimpleSpeciesReference(SBase):
    """

    Abstract class for references to species in reactions.

    As mentioned in the description of Reaction, every species that enters
    into a given reaction must appear in that reaction's lists of
    reactants, products and/or modifiers.  In an SBML model, all species
    that may participate in any reaction are listed in the 'listOfSpecies'
    element of the top-level Model object.  Lists of products, reactants
    and modifiers in Reaction objects do not introduce new species, but
    rather, they refer back to those listed in the model's top-level
    'listOfSpecies'.  For reactants and products, the connection is made
    using SpeciesReference objects; for modifiers, it is made using
    ModifierSpeciesReference objects.  SimpleSpeciesReference is an
    abstract type that serves as the parent class of both SpeciesReference
    and ModifierSpeciesReference.  It is used simply to hold the
    attributes and elements that are common to the latter two structures.

    The SimpleSpeciesReference structure has a mandatory attribute,
    'species', which must be a text string conforming to the identifer
    syntax permitted in SBML.  This attribute is inherited by the
    SpeciesReference and ModifierSpeciesReference subclasses derived from
    SimpleSpeciesReference.  The value of the 'species' attribute must be
    the identifier of a species defined in the enclosing Model.  The
    species is thereby declared as participating in the reaction being
    defined.  The precise role of that species as a reactant, product, or
    modifier in the reaction is determined by the subclass of
    SimpleSpeciesReference (i.e., either SpeciesReference or
    ModifierSpeciesReference) in which the identifier appears.

    SimpleSpeciesReference also contains an optional attribute, 'id',
    allowing instances to be referenced from other structures.  No SBML
    structures currently do this; however, such structures are anticipated
    in future SBML Levels.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SimpleSpeciesReference, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SimpleSpeciesReference, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_SimpleSpeciesReference
    __del__ = lambda self: None

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


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

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is now recommended to use the
        getIdAttribute() function instead.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns the id of this SimpleSpeciesReference.

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.SimpleSpeciesReference_getId(self)


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


        Returns the value of the 'name' attribute of this
        SimpleSpeciesReference object.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns the name of this SBML object, or the empty string if not set
        or unsettable.

        See also getIdAttribute(), isSetName(), setName(), unsetName().

        """
        return _libsbml.SimpleSpeciesReference_getName(self)


    def getSpecies(self):
        """
        getSpecies(SimpleSpeciesReference self) -> string


        Get the value of the 'species' attribute.

        Returns the value of the attribute 'species' for this
        SimpleSpeciesReference.

        """
        return _libsbml.SimpleSpeciesReference_getSpecies(self)


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


        Predicate returning 'True' if this SimpleSpeciesReference's 'id'
        attribute is set.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns 'True' if the 'id' attribute of this SBML object is set,
        'False' otherwise.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is recommended that callers use
        isSetIdAttribute() instead.

        See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(),
        isSetIdAttribute().

        """
        return _libsbml.SimpleSpeciesReference_isSetId(self)


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


        Predicate returning 'True' if this SimpleSpeciesReference's 'name'
        attribute is set.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns 'True' if the 'name' attribute of this SBML object is set,
        'False' otherwise.

        See also getName(), setName(), unsetName().

        """
        return _libsbml.SimpleSpeciesReference_isSetName(self)


    def isSetSpecies(self):
        """
        isSetSpecies(SimpleSpeciesReference self) -> bool


        Predicate returning 'True' if this SimpleSpeciesReference's 'species'
        attribute is set.

        Returns 'True' if the 'species' attribute of this
        SimpleSpeciesReference is set, 'False' otherwise.

        """
        return _libsbml.SimpleSpeciesReference_isSetSpecies(self)


    def setSpecies(self, sid):
        """
        setSpecies(SimpleSpeciesReference self, string sid) -> int


        Sets the 'species' attribute of this SimpleSpeciesReference.

        The identifier string passed in 'sid' is copied.

        Parameter 'sid' is the identifier of a species defined in the
        enclosing Model's ListOfSpecies.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.SimpleSpeciesReference_setSpecies(self, sid)


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


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

        The string 'sid' is copied.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Parameter 'sid' is the string to use as the identifier of this object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.SimpleSpeciesReference_setId(self, sid)


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


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

        The string in 'name' is copied.

        Parameter 'name' is the new name for the SBML object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.SimpleSpeciesReference_setName(self, name)


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


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

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.SimpleSpeciesReference_unsetId(self)


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


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

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getName(), setName(), isSetName().

        """
        return _libsbml.SimpleSpeciesReference_unsetName(self)


    def unsetSpecies(self):
        """
        unsetSpecies(SimpleSpeciesReference self) -> int


        Unsets the value of the 'species' attribute of this
        SimpleSpeciesReference.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.SimpleSpeciesReference_unsetSpecies(self)


    def isModifier(self):
        """
        isModifier(SimpleSpeciesReference self) -> bool


        Predicate returning 'True' if this is a ModifierSpeciesReference.

        Returns 'True' if this SimpleSpeciesReference's subclass is
        ModiferSpeciesReference, 'False' if it is a plain SpeciesReference.

        """
        return _libsbml.SimpleSpeciesReference_isModifier(self)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(SimpleSpeciesReference self, string oldid, string newid)


        Replaces all uses of a given 'SIdRef' type attribute value with
        another value.

        In SBML, object identifiers are of a data type called SId. In SBML
        Level 3, an explicit data type called SIdRef was introduced for
        attribute values that refer to SId values; in previous Levels of SBML,
        this data type did not exist and attributes were simply described to
        as 'referring to an identifier', but the effective data type was the
        same as SIdRef in Level 3.  These and other methods of libSBML refer
        to the type SIdRef for all Levels of SBML, even if the corresponding
        SBML specification did not explicitly name the data type.

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas in MathML content, comparing the referenced
        identifiers to the value of 'oldid'.  If any matches are found, the
        matching values are replaced with 'newid'.  The method does not
        descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.SimpleSpeciesReference_renameSIdRefs(self, oldid, newid)

SimpleSpeciesReference_swigregister = _libsbml.SimpleSpeciesReference_swigregister
SimpleSpeciesReference_swigregister(SimpleSpeciesReference)

class SpeciesReference(SimpleSpeciesReference):
    """

    A reference to an SBML species in a reaction.

    The Reaction structure provides a way to express which species act as
    reactants and which species act as products in a reaction.  In a given
    reaction, references to those species acting as reactants and/or
    products are made using instances of SpeciesReference structures in a
    Reaction object's lists of reactants and products.

    A species can occur more than once in the lists of reactants and
    products of a given Reaction instance.  The effective stoichiometry
    for a species in a reaction is the sum of the stoichiometry values
    given on the SpeciesReference object in the list of products minus the
    sum of stoichiometry values given on the SpeciesReference objects in
    the list of reactants.  A positive value indicates the species is
    effectively a product and a negative value indicates the species is
    effectively a reactant.  SBML places no restrictions on the effective
    stoichiometry of a species in a reaction; for example, it can be zero.
    In the following SBML fragment, the two reactions have the same
    effective stoichiometry for all their species:

       <reaction id='x'>
           <listOfReactants>
               <speciesReference species='a'/>
               <speciesReference species='a'/>
               <speciesReference species='b'/>
           </listOfReactants>
           <listOfProducts>
               <speciesReference species='c'/>
               <speciesReference species='b'/>
           </listProducts>
       </reaction>
       <reaction id='y'>
           <listOfReactants>
               <speciesReference species='a' stoichiometry='2'/>
           </listOfReactants>
           <listOfProducts>
               <speciesReference species='c'/>
           </listProducts>
       </reaction>

    The precise structure of SpeciesReference differs between SBML Level 2
    and Level 3.  We discuss the two variants in separate sections below.

    SpeciesReference in SBML Level 2
    ======================================================================

    The mandatory 'species' attribute of SpeciesReference must have as its
    value the identifier of an existing species defined in the enclosing
    Model.  The species is thereby designated as a reactant or product in
    the reaction.  Which one it is (i.e., reactant or product) is
    indicated by whether the SpeciesReference appears in the Reaction's
    'reactant' or 'product' lists.

    Product and reactant stoichiometries can be specified using either
    'stoichiometry' or 'stoichiometryMath' in a SpeciesReference object.
    The 'stoichiometry' attribute is of type double and should contain
    values greater than '0' (false).  The 'stoichiometryMath' element is
    implemented as an element containing a MathML expression.  These two
    are mutually exclusive; only one of 'stoichiometry' or
    'stoichiometryMath' should be defined in a given SpeciesReference
    instance.  When neither the attribute nor the element is present, the
    value of 'stoichiometry' in the SpeciesReference instance defaults to
    '1.'

    For maximum interoperability, the 'stoichiometry' attribute should be
    used in preference to 'stoichiometryMath' when a species'
    stoichiometry is a simple scalar number (integer or decimal).  When
    the stoichiometry is a rational number, or when it is a more
    complicated formula, 'stoichiometryMath' must be used.  The MathML
    expression in 'stoichiometryMath' may also refer to identifiers of
    entities in a model (except reaction identifiers).  However, the only
    species identifiers that can be used in 'stoichiometryMath' are those
    referenced in the Reaction list of reactants, products and modifiers.

    The following is a simple example of a species reference for species
    'X0,' with stoichiometry '2,' in a list of reactants within a reaction
    having the identifier 'J1:'

       <model>
           ...
           <listOfReactions>
               <reaction id='J1'>
                   <listOfReactants>
                       <speciesReference species='X0' stoichiometry='2'>
                   </listOfReactants>
                   ...
               </reaction>
               ...
           </listOfReactions>
           ...
       </model>

    The following is a more complex example of a species reference for
    species X0, with a stoichiometry formula consisting of the parameter
    'x:'

       <model>
           ...
           <listOfReactions>
               <reaction id='J1'>
                   <listOfReactants>
                       <speciesReference species='X0'>
                           <stoichiometryMath>
                               <math xmlns='http://www.w3.org/1998/Math/MathML'>
                                   <ci>x</ci>
                               </math>
                           </stoichiometryMath>
                       </speciesReference>
                   </listOfReactants>
                   ...
               </reaction>
               ...
           </listOfReactions>
           ...
       </model>

    SpeciesReference in SBML Level 3
    ======================================================================

    In Level 2's definition of a reaction, the stoichiometry attribute of
    a SpeciesReference is actually a combination of two factors, the
    standard biochemical stoichiometry and a conversion factor that may be
    needed to translate the units of the species quantity to the units of
    the reaction rate. Unfortunately, Level 2 offers no direct way of
    decoupling these two factors, or for explicitly indicating the units.
    The only way to do it in Level 2 is to use the StoichiometryMath
    object associated with SpeciesReferences, and to reference SBML
    Parameter objects from within the StoichiometryMath formula. This
    works because Parameter offers a way to attach units to a numerical
    value, but the solution is indirect and awkward for something that
    should be a simple matter.  Moreover, the question of how to properly
    encode stoichiometries in SBML reactions has caused much confusion
    among implementors of SBML software.

    SBML Level 3 approaches this problem differently.  It (1) extends the
    the use of the SpeciesReference identifier to represent the value of
    the 'stoichiometry' attribute, (2) makes the 'stoichiometry' attribute
    optional, (3) removes StoichiometryMath, and (4) adds a new 'constant'
    boolean attribute on SpeciesReference.

    As in Level 2, the 'stoichiometry' attribute is of type 'float' and
    should contain values greater than zero ('0).'  A missing
    'stoichiometry' implies that the stoichiometry is either unknown, or
    to be obtained from an external source, or determined by an
    InitialAssignment object or other SBML construct elsewhere in the
    model.

    A species reference's stoichiometry is set by its 'stoichiometry'
    attribute exactly once.  If the SpeciesReference object's 'constant'
    attribute has the value 'True,' then the stoichiometry is fixed and
    cannot be changed except by an InitialAssignment object.  These two
    methods of setting the stoichiometry (i.e., using 'stoichiometry'
    directly, or using InitialAssignment) differ in that the
    'stoichiometry' attribute can only be set to a literal floating-point
    number, whereas InitialAssignment allows the value to be set using an
    arbitrary mathematical expression.  (As an example, the approach could
    be used to set the stoichiometry to a rational number of the form p/q,
    where p and q are integers, something that is occasionally useful in
    the context of biochemical reaction networks.)  If the species
    reference's 'constant' attribute has the value 'False,' the species
    reference's value may be overridden by an InitialAssignment or changed
    by AssignmentRule or AlgebraicRule, and in addition, for simulation
    time t > 0, it may also be changed by a RateRule or Event objects.
    (However, some of these constructs are mutually exclusive; see the
    SBML Level 3 Core specifiation for more details.)  It is not an error
    to define 'stoichiometry' on a species reference and also redefine the
    stoichiometry using an InitialAssignment, but the 'stoichiometry'
    attribute in that case is ignored.

    The value of the 'id' attribute of a SpeciesReference can be used as
    the content of a <ci> element in MathML formulas elsewhere in the
    model.  When the identifier appears in a MathML <ci> element, it
    represents the stoichiometry of the corresponding species in the
    reaction where the SpeciesReference object instance appears.  More
    specifically, it represents the value of the 'stoichiometry' attribute
    on the SpeciesReference object.

    In SBML Level 3, the unit of measurement associated with the value of
    a species' stoichiometry is always considered to be 'dimensionless.'
    This has the following implications:

    * When a species reference's identifier appears in mathematical
    formulas elsewhere in the model, the unit associated with that value
    is 'dimensionless.'

    * The units of the 'math' elements of AssignmentRule,
    InitialAssignment and EventAssignment objects setting the
    stoichiometry of the species reference should be 'dimensionless.'

    * If a species reference's identifier is the subject of a RateRule,
    the unit associated with the RateRule object's value should be
    dimensionless/time, where time is the model-wide unit of time set on
    the Model object.

    """

    __swig_setmethods__ = {}
    for _s in [SimpleSpeciesReference]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SpeciesReference, name, value)
    __swig_getmethods__ = {}
    for _s in [SimpleSpeciesReference]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SpeciesReference, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_SpeciesReference
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(SpeciesReference self, unsigned int level, unsigned int version) -> SpeciesReference
        __init__(SpeciesReference self, SBMLNamespaces sbmlns) -> SpeciesReference
        __init__(SpeciesReference self, SpeciesReference orig) -> SpeciesReference


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            SpeciesReference(SBMLNamespaces sbmlns)

        Creates a new SpeciesReference using the given SBMLNamespaces object
        'sbmlns'.

        Parameter 'sbmlns' is an SBMLNamespaces object.

        Throws SBMLConstructorException: Thrown if the given 'sbmlns' is
        inconsistent or incompatible with this object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            SpeciesReference(long level, long version)

        Creates a new SpeciesReference using the given SBML 'level' and
        'version' values.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        SpeciesReference.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this SpeciesReference.

        Throws SBMLConstructorException: Thrown if the given 'level' and
        'version' combination are invalid or if this object is incompatible
        with the given level and version.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            SpeciesReference(SpeciesReference orig)

        Copy constructor; creates a copy of this SpeciesReference.

        Parameter 'orig' is the SpeciesReference instance to copy.

        """
        this = _libsbml.new_SpeciesReference(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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


        Creates and returns a deep copy of this SpeciesReference object.

        Returns the (deep) copy of this SpeciesReference object.

        """
        return _libsbml.SpeciesReference_clone(self)


    def initDefaults(self):
        """
        initDefaults(SpeciesReference self)


        Initializes the fields of this SpeciesReference object to 'typical'
        default values.

        The SBML SpeciesReference component has slightly different aspects and
        default attribute values in different SBML Levels and Versions. This
        method sets the values to certain common defaults, based mostly on
        what they are in SBML Level 2.  Specifically:

        * Sets attribute 'stoichiometry' to '1.0'

        * (Applies to Level 1 models only) Sets attribute 'denominator' to
        '1' See also getDenominator(), setDenominator(), getStoichiometry(),
        setStoichiometry(), getStoichiometryMath(), setStoichiometryMath().

        """
        return _libsbml.SpeciesReference_initDefaults(self)


    def getStoichiometry(self):
        """
        getStoichiometry(SpeciesReference self) -> double


        Get the value of the 'stoichiometry' attribute.

        In SBML Level 2, product and reactant stoichiometries can be specified
        using either 'stoichiometry' or 'stoichiometryMath' in a
        SpeciesReference object.  The former is to be used when a
        stoichiometry is simply a scalar number, while the latter is for
        occasions when it needs to be a rational number or it needs to
        reference other mathematical expressions.  The 'stoichiometry'
        attribute is of type 'float' and should contain values greater than
        zero ('0).'  The 'stoichiometryMath' element is implemented as an
        element containing a MathML expression.  These two are mutually
        exclusive; only one of 'stoichiometry' or 'stoichiometryMath' should
        be defined in a given SpeciesReference instance.  When neither the
        attribute nor the element is present, the value of 'stoichiometry' in
        the SpeciesReference instance defaults to '1.'  For maximum
        interoperability between different software tools, the 'stoichiometry'
        attribute should be used in preference to 'stoichiometryMath' when a
        species' stoichiometry is a simple scalar number (integer or decimal).

        In SBML Level 3, there is no StoichiometryMath, and SpeciesReference
        objects have only the 'stoichiometry' attribute.

        Returns the value of the (scalar) 'stoichiometry' attribute of this
        SpeciesReference.

        See also getStoichiometryMath().

        """
        return _libsbml.SpeciesReference_getStoichiometry(self)


    def getStoichiometryMath(self, *args):
        """
        getStoichiometryMath(SpeciesReference self) -> StoichiometryMath
        getStoichiometryMath(SpeciesReference self) -> StoichiometryMath


        Get the content of the 'stoichiometryMath' subelement as an ASTNode
        tree.

        The 'stoichiometryMath' element exists only in SBML Level 2.  There,
        product and reactant stoichiometries can be specified using either
        'stoichiometry' or 'stoichiometryMath' in a SpeciesReference object.
        The former is to be used when a stoichiometry is simply a scalar
        number, while the latter is for occasions when it needs to be a
        rational number or it needs to reference other mathematical
        expressions.  The 'stoichiometry' attribute is of type 'float' and
        should contain values greater than zero ('0).'  The
        'stoichiometryMath' element is implemented as an element containing a
        MathML expression.  These two are mutually exclusive; only one of
        'stoichiometry' or 'stoichiometryMath' should be defined in a given
        SpeciesReference instance.  When neither the attribute nor the element
        is present, the value of 'stoichiometry' in the SpeciesReference
        instance defaults to '1.'  For maximum interoperability between
        different software tools, the 'stoichiometry' attribute should be used
        in preference to 'stoichiometryMath' when a species' stoichiometry is
        a simple scalar number (integer or decimal).

        Returns the content of the 'stoichiometryMath' subelement of this
        SpeciesReference.

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


    def getDenominator(self):
        """
        getDenominator(SpeciesReference self) -> int


        Get the value of the 'denominator' attribute, for the case of a
        rational-numbered stoichiometry or a model in SBML Level 1.

        The 'denominator' attribute is only actually written out in the case
        of an SBML Level 1 model.  In SBML Level 2, rational-number
        stoichiometries are written as MathML elements in the
        'stoichiometryMath' subelement.  However, as a convenience to users,
        libSBML allows the creation and manipulation of rational-number
        stoichiometries by supplying the numerator and denominator directly
        rather than having to manually create an ASTNode object.  LibSBML will
        write out the appropriate constructs (either a combination of
        'stoichiometry' and 'denominator' in the case of SBML Level 1, or a
        'stoichiometryMath' subelement in the case of SBML Level 2). However,
        as the 'stoichiometryMath' subelement was removed in SBML Level 3,
        automatic translation of the 'denominator' attribute is no longer
        supported for that level.

        Returns the value of the 'denominator' attribute of this
        SpeciesReference.

        """
        return _libsbml.SpeciesReference_getDenominator(self)


    def getConstant(self):
        """
        getConstant(SpeciesReference self) -> bool


        Get the value of the 'constant' attribute.

        Returns the value of the 'constant' attribute of this
        SpeciesReference.

        """
        return _libsbml.SpeciesReference_getConstant(self)


    def isSetStoichiometryMath(self):
        """
        isSetStoichiometryMath(SpeciesReference self) -> bool


        Predicate returning 'True' if this SpeciesReference's
        'stoichiometryMath' subelement is set

        Returns 'True' if the 'stoichiometryMath' subelement of this
        SpeciesReference is set, 'False' otherwise.

        """
        return _libsbml.SpeciesReference_isSetStoichiometryMath(self)


    def isSetConstant(self):
        """
        isSetConstant(SpeciesReference self) -> bool


        Predicate returning 'True' if this SpeciesReference's 'constant'
        attribute is set

        Returns 'True' if the 'constant' attribute of this SpeciesReference is
        set, 'False' otherwise.

        """
        return _libsbml.SpeciesReference_isSetConstant(self)


    def isSetStoichiometry(self):
        """
        isSetStoichiometry(SpeciesReference self) -> bool


        Predicate returning 'True' if this SpeciesReference's 'stoichiometry'
        attribute is set.

        Returns 'True' if the 'stoichiometry' attribute of this
        SpeciesReference is set, 'False' otherwise.

        """
        return _libsbml.SpeciesReference_isSetStoichiometry(self)


    def setStoichiometry(self, value):
        """
        setStoichiometry(SpeciesReference self, double value) -> int


        Sets the value of the 'stoichiometry' attribute of this
        SpeciesReference.

        In SBML Level 2, product and reactant stoichiometries can be specified
        using either 'stoichiometry' or 'stoichiometryMath' in a
        SpeciesReference object.  The former is to be used when a
        stoichiometry is simply a scalar number, while the latter is for
        occasions when it needs to be a rational number or it needs to
        reference other mathematical expressions.  The 'stoichiometry'
        attribute is of type 'float' and should contain values greater than
        zero ('0).'  The 'stoichiometryMath' element is implemented as an
        element containing a MathML expression.  These two are mutually
        exclusive; only one of 'stoichiometry' or 'stoichiometryMath' should
        be defined in a given SpeciesReference instance.  When neither the
        attribute nor the element is present, the value of 'stoichiometry' in
        the SpeciesReference instance defaults to '1.'  For maximum
        interoperability between different software tools, the 'stoichiometry'
        attribute should be used in preference to 'stoichiometryMath' when a
        species' stoichiometry is a simple scalar number (integer or decimal).

        In SBML Level 3, there is no StoichiometryMath, and SpeciesReference
        objects have only the 'stoichiometry' attribute.

        Parameter 'value' is the new value of the 'stoichiometry' attribute.

        Note: In SBML Level 2, the 'stoichiometryMath' subelement of this
        SpeciesReference object will be unset because the 'stoichiometry'
        attribute and the stoichiometryMath' subelement are mutually
        exclusive.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.SpeciesReference_setStoichiometry(self, value)


    def setStoichiometryMath(self, math):
        """
        setStoichiometryMath(SpeciesReference self, StoichiometryMath math) -> int


        Sets the 'stoichiometryMath' subelement of this SpeciesReference.

        The Abstract Syntax Tree in 'math' is copied.

        In SBML Level 2, product and reactant stoichiometries can be specified
        using either 'stoichiometry' or 'stoichiometryMath' in a
        SpeciesReference object.  The former is to be used when a
        stoichiometry is simply a scalar number, while the latter is for
        occasions when it needs to be a rational number or it needs to
        reference other mathematical expressions.  The 'stoichiometry'
        attribute is of type 'float' and should contain values greater than
        zero ('0).'  The 'stoichiometryMath' element is implemented as an
        element containing a MathML expression.  These two are mutually
        exclusive; only one of 'stoichiometry' or 'stoichiometryMath' should
        be defined in a given SpeciesReference instance.  When neither the
        attribute nor the element is present, the value of 'stoichiometry' in
        the SpeciesReference instance defaults to '1.'  For maximum
        interoperability between different software tools, the 'stoichiometry'
        attribute should be used in preference to 'stoichiometryMath' when a
        species' stoichiometry is a simple scalar number (integer or decimal).

        In SBML Level 3, there is no StoichiometryMath, and SpeciesReference
        objects have only the 'stoichiometry' attribute.

        Parameter 'math' is the StoichiometryMath expression that is to be
        copied as the content of the 'stoichiometryMath' subelement.

        Note: In SBML Level 2, the 'stoichiometry' attribute of this
        SpeciesReference object will be unset (isSetStoichiometry() will
        return 'False' although getStoichiometry() will return '1.0)' if the
        given math is not null because the 'stoichiometry' attribute and the
        stoichiometryMath' subelement are mutually exclusive.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        """
        return _libsbml.SpeciesReference_setStoichiometryMath(self, math)


    def setDenominator(self, value):
        """
        setDenominator(SpeciesReference self, int value) -> int


        Set the value of the 'denominator' attribute, for the case of a
        rational-numbered stoichiometry or a model in SBML Level 1.

        The 'denominator' attribute is only actually written out in the case
        of an SBML Level 1 model.  In SBML Level 2, rational-number
        stoichiometries are written as MathML elements in the
        'stoichiometryMath' subelement.  However, as a convenience to users,
        libSBML allows the creation and manipulation of rational-number
        stoichiometries by supplying the numerator and denominator directly
        rather than having to manually create an ASTNode object.  LibSBML will
        write out the appropriate constructs (either a combination of
        'stoichiometry' and 'denominator' in the case of SBML Level 1, or a
        'stoichiometryMath' subelement in the case of SBML Level 2). However,
        as the 'stoichiometryMath' subelement was removed in SBML Level 3,
        automatic translation of the 'denominator'  attribute is no longer
        supported for that level.

        Parameter 'value' is the scalar value.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        """
        return _libsbml.SpeciesReference_setDenominator(self, value)


    def setConstant(self, flag):
        """
        setConstant(SpeciesReference self, bool flag) -> int


        Sets the 'constant' attribute of this SpeciesReference to the given
        boolean 'flag'.

        Parameter 'flag' is a boolean, the value for the 'constant' attribute
        of this SpeciesReference instance.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        """
        return _libsbml.SpeciesReference_setConstant(self, flag)


    def unsetStoichiometryMath(self):
        """
        unsetStoichiometryMath(SpeciesReference self) -> int


        Unsets the 'stoichiometryMath' subelement of this SpeciesReference.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        * LIBSBML_OPERATION_FAILED

        In SBML Level 2, product and reactant stoichiometries can be specified
        using either 'stoichiometry' or 'stoichiometryMath' in a
        SpeciesReference object.  The former is to be used when a
        stoichiometry is simply a scalar number, while the latter is for
        occasions when it needs to be a rational number or it needs to
        reference other mathematical expressions.  The 'stoichiometry'
        attribute is of type 'float' and should contain values greater than
        zero ('0).'  The 'stoichiometryMath' element is implemented as an
        element containing a MathML expression.  These two are mutually
        exclusive; only one of 'stoichiometry' or 'stoichiometryMath' should
        be defined in a given SpeciesReference instance.  When neither the
        attribute nor the element is present, the value of 'stoichiometry' in
        the SpeciesReference instance defaults to '1.'  For maximum
        interoperability between different software tools, the 'stoichiometry'
        attribute should be used in preference to 'stoichiometryMath' when a
        species' stoichiometry is a simple scalar number (integer or decimal).

        In SBML Level 3, there is no StoichiometryMath, and SpeciesReference
        objects have only the 'stoichiometry' attribute.

        Note: In SBML Level 2, the 'stoichiometry' attribute of this
        SpeciesReference object will be reset to a default value ('1.0)' if
        the 'stoichiometry' attribute has not been set.

        """
        return _libsbml.SpeciesReference_unsetStoichiometryMath(self)


    def unsetStoichiometry(self):
        """
        unsetStoichiometry(SpeciesReference self) -> int


        Unsets the 'stoichiometry' attribute of this SpeciesReference.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        Note: In SBML Level 1, the 'stoichiometry' attribute of this
        SpeciesReference object will be just reset to a default value ('1.0)'
        and isSetStoichiometry() will still return 'True.'  In SBML Level 2,
        the 'stoichiometry' attribute of this object will be unset (which will
        result in isSetStoichiometry() returning 'False,' although
        getStoichiometry() will return '1.0)' if the 'stoichiometryMath'
        subelement is set, otherwise the attribute will be just reset to the
        default value ('1.0)' (and isSetStoichiometry() will still return
        'True).'  In SBML Level 3, the 'stoichiometry' attribute of this
        object will be set to 'NaN' and isSetStoichiometry() will return
        'False.'

        """
        return _libsbml.SpeciesReference_unsetStoichiometry(self)


    def unsetConstant(self):
        """
        unsetConstant(SpeciesReference self) -> int


        Unsets the 'constant' attribute of this SpeciesReference.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        """
        return _libsbml.SpeciesReference_unsetConstant(self)


    def createStoichiometryMath(self):
        """
        createStoichiometryMath(SpeciesReference self) -> StoichiometryMath


        Creates a new, empty StoichiometryMath object, adds it to this
        SpeciesReference, and returns it.

        Returns the newly created StoichiometryMath object instance.

        Note: This function has no effect on SBML Level 1 or Level 3
        SpeciesReference objects, neither of which have StoichiometryMath
        children.

        See also Reaction.addReactant(), Reaction.addProduct().

        """
        return _libsbml.SpeciesReference_createStoichiometryMath(self)


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            setAnnotation(XMLNode annotation)

        Sets the value of the 'annotation' subelement of this SBML object to a
        copy of '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 '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().

        Parameter 'annotation' is an XML structure that is to be used as the
        content of the 'annotation' subelement of this object.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        See also appendAnnotation(), appendAnnotation().

        ______________________________________________________________________
        Method variant with the following signature:

            setAnnotation(string annotation)

        Sets the value of the 'annotation' subelement of this SBML object to a
        copy of '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 '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().

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

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also appendAnnotation(), appendAnnotation().

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


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            appendAnnotation(XMLNode annotation)

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

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

        Parameter 'annotation' is an XML structure that is to be copied and
        appended to the content of the 'annotation' subelement of this object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also setAnnotation(), setAnnotation().

        ______________________________________________________________________
        Method variant with the following signature:

            appendAnnotation(string annotation)

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

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

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

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also setAnnotation(), setAnnotation().

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


    def getTypeCode(self):
        """
        getTypeCode(SpeciesReference self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_SPECIES_REFERENCE
        (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.SpeciesReference_getTypeCode(self)


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


        Returns the XML element name of this object, which for
        SpeciesReference, is always ''speciesReference'.'

        Returns the name of this element, i.e., ''speciesReference'.'

        """
        return _libsbml.SpeciesReference_getElementName(self)


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


        Predicate returning 'True' if all the required attributes for this
        SpeciesReference object have been set.

        The required attributes for a SpeciesReference object are:

        * 'species'

        * 'constant' (only available SBML Level 3)

        Returns 'True' if the required attributes have been set, 'False'
        otherwise.

        """
        return _libsbml.SpeciesReference_hasRequiredAttributes(self)

SpeciesReference_swigregister = _libsbml.SpeciesReference_swigregister
SpeciesReference_swigregister(SpeciesReference)

class ListOfSpeciesReferences(ListOf):
    """

    A list of SpeciesReference objects.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfSpeciesReferences, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfSpeciesReferences, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ListOfSpeciesReferences self, unsigned int level, unsigned int version) -> ListOfSpeciesReferences
        __init__(ListOfSpeciesReferences self, SBMLNamespaces sbmlns) -> ListOfSpeciesReferences


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfSpeciesReferences(SBMLNamespaces sbmlns)

        Creates a new ListOfSpeciesReferences object.

        The object is constructed such that it is valid for the SBML Level and
        Version combination determined by the SBMLNamespaces object in
        'sbmlns'.

        Parameter 'sbmlns' is an SBMLNamespaces object that is used to
        determine the characteristics of the ListOfSpeciesReferences object to
        be created.

        Throws SBMLConstructorException: Thrown if the given 'sbmlns' is
        inconsistent or incompatible with this object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfSpeciesReferences(long level, long version)

        Creates a new, empty ListOfSpeciesReferences object.

        The object is constructed such that it is valid for the given SBML
        Level and Version combination.

        Parameter 'level' is the SBML Level.

        Parameter 'version' is the Version within the SBML Level.

        Throws SBMLConstructorException: Thrown if the given 'level' and
        'version' combination are invalid or if this object is incompatible
        with the given level and version.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        """
        this = _libsbml.new_ListOfSpeciesReferences(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ListOfSpeciesReferences self) -> ListOfSpeciesReferences


        Creates and returns a deep copy of this ListOfSpeciesReferences
        object.

        Returns the (deep) copy of this ListOfSpeciesReferences object.

        """
        return _libsbml.ListOfSpeciesReferences_clone(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfSpeciesReferences self) -> int


        Returns the libSBML type code for the objects contained in this ListOf
        (i.e., SpeciesReference objects, if the list is non-empty).

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for objects contained in this list:
        SBML_SPECIES_REFERENCE (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfSpeciesReferences_getItemTypeCode(self)


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


        Returns the XML element name of this object.

        For ListOfSpeciesReferences, the XML element name is
        ''listOfSpeciesReferences'.'

        Returns the name of this element, i.e., ''listOfSpeciesReferences'.'

        """
        return _libsbml.ListOfSpeciesReferences_getElementName(self)


    def get(self, *args):
        """
        get(ListOfSpeciesReferences self, unsigned int n) -> SimpleSpeciesReference
        get(ListOfSpeciesReferences self, unsigned int n) -> SimpleSpeciesReference
        get(ListOfSpeciesReferences self, string sid) -> SimpleSpeciesReference
        get(ListOfSpeciesReferences self, string sid) -> SimpleSpeciesReference


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a SpeciesReference from the ListOfSpeciesReferences.

        Parameter 'n' is the index number of the SpeciesReference to get.

        Returns the nth SpeciesReference in this ListOfSpeciesReferences. If
        the index 'n' is invalid, 'None' is returned.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a SpeciesReference from the ListOfSpeciesReferences based on its
        identifier.

        Parameter 'sid' is a string representing the identifier  of the
        SpeciesReference to get.

        Returns SpeciesReference in this ListOfSpeciesReferences with the
        given 'sid' or 'None' if no such SpeciesReference exists.

        See also get(), size().

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


    def remove(self, *args):
        """
        remove(ListOfSpeciesReferences self, unsigned int n) -> SimpleSpeciesReference
        remove(ListOfSpeciesReferences self, string sid) -> SimpleSpeciesReference


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth item from this ListOfSpeciesReferences items and
        returns a pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the item to remove.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes item in this ListOfSpeciesReferences 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 'sid', then
        'None' is returned.

        Parameter 'sid' is the identifier of the item to remove.

        Returns the item removed.  As mentioned above, the caller owns the
        returned item.

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


    def getType(self):
        """
        getType(ListOfSpeciesReferences self) -> unsigned int


        Internal implementation method.

        """
        return _libsbml.ListOfSpeciesReferences_getType(self)

    __swig_destroy__ = _libsbml.delete_ListOfSpeciesReferences
    __del__ = lambda self: None
ListOfSpeciesReferences_swigregister = _libsbml.ListOfSpeciesReferences_swigregister
ListOfSpeciesReferences_swigregister(ListOfSpeciesReferences)

class ModifierSpeciesReference(SimpleSpeciesReference):
    """

    A reference to an SBML modifier species.

    Sometimes a species appears in the kinetic rate formula of a reaction
    but is itself neither created nor destroyed in that reaction (for
    example, because it acts as a catalyst or inhibitor).  In SBML, all
    such species are simply called modifiers without regard to the
    detailed role of those species in the model.  The Reaction structure
    provides a way to express which species act as modifiers in a given
    reaction.  This is the purpose of the list of modifiers available in
    Reaction.  The list contains instances of ModifierSpeciesReference
    structures.

    The ModifierSpeciesReference structure inherits the mandatory
    attribute 'species' and optional attributes 'id' and 'name' from the
    parent class SimpleSpeciesReference.  See the description of
    SimpleSpeciesReference for more information about these.

    The value of the 'species' attribute must be the identifier of a
    species defined in the enclosing Model; this species is designated as
    a modifier for the current reaction.  A reaction may have any number
    of modifiers. It is permissible for a modifier species to appear
    simultaneously in the list of reactants and products of the same
    reaction where it is designated as a modifier, as well as to appear in
    the list of reactants, products and modifiers of other reactions in
    the model.

    """

    __swig_setmethods__ = {}
    for _s in [SimpleSpeciesReference]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ModifierSpeciesReference, name, value)
    __swig_getmethods__ = {}
    for _s in [SimpleSpeciesReference]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ModifierSpeciesReference, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ModifierSpeciesReference self, unsigned int level, unsigned int version) -> ModifierSpeciesReference
        __init__(ModifierSpeciesReference self, SBMLNamespaces sbmlns) -> ModifierSpeciesReference


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ModifierSpeciesReference(SBMLNamespaces sbmlns)

        Creates a new ModifierSpeciesReference using the given SBMLNamespaces
        object 'sbmlns'.

        Parameter 'sbmlns' is an SBMLNamespaces object.

        Throws SBMLConstructorException: Thrown if the given 'sbmlns' is
        inconsistent or incompatible with this object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            ModifierSpeciesReference(long level, long version)

        Creates a new ModifierSpeciesReference using the given SBML 'level'
        and 'version' values.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        ModifierSpeciesReference.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this ModifierSpeciesReference.

        Throws SBMLConstructorException: Thrown if the given 'level' and
        'version' combination are invalid or if this object is incompatible
        with the given level and version.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        """
        this = _libsbml.new_ModifierSpeciesReference(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_ModifierSpeciesReference
    __del__ = lambda self: None

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


        Creates and returns a deep copy of this ModifierSpeciesReference
        object.

        Returns the (deep) copy of this ModifierSpeciesReference object.

        """
        return _libsbml.ModifierSpeciesReference_clone(self)


    def getTypeCode(self):
        """
        getTypeCode(ModifierSpeciesReference self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object:
        SBML_MODIFIER_SPECIES_REFERENCE (default).

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ModifierSpeciesReference_getTypeCode(self)


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


        Returns the XML element name of this object, which for Species, is
        always ''modifierSpeciesReference'.'

        Returns the name of this element, i.e., ''modifierSpeciesReference'.'

        """
        return _libsbml.ModifierSpeciesReference_getElementName(self)


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


        Predicate returning 'True' if all the required attributes for this
        ModifierSpeciesReference object have been set.

        The required attributes for a ModifierSpeciesReference object are:
        species

        Returns 'True' if the required attributes have been set, 'False'
        otherwise.

        """
        return _libsbml.ModifierSpeciesReference_hasRequiredAttributes(self)

ModifierSpeciesReference_swigregister = _libsbml.ModifierSpeciesReference_swigregister
ModifierSpeciesReference_swigregister(ModifierSpeciesReference)

class Event(SBase):
    """

    A discontinuous SBML event.

    An SBML Event object defines when the event can occur, the variables
    that are affected by it, how the variables are affected, and the
    event's relationship to other events.  The effect of the event can
    optionally be delayed after the occurrence of the condition which
    invokes it.

    The operation of Event is divided into two phases (even when the event
    is not delayed): one when the event is triggered, and the other when
    the event is executed.  Trigger objects define the conditions for
    triggering an event, Delay objects define when the event is actually
    executed, EventAssignment objects define the effects of executing the
    event, and (in SBML Level 3) Priority objects influence the order of
    EventAssignment performance in cases of simultaneous events.  Please
    consult the descriptions of Trigger, Delay, EventAssignment and
    Priority for more information.

    SBML Level/Version differences
    ======================================================================

    SBML Level 2
    ......................................................................

    In SBML Level 2 versions before Version 4, the semantics of Event time
    delays were defined such that the expressions in the event's
    assignments were always evaluated at the time the event was triggered.
    This definition made it difficult to define an event whose assignment
    formulas were meant to be evaluated at the time the event was executed
    (i.e., after the time period defined by the value of the Delay
    element, or after any other simultaneous event may have been executed
    and changed the model state). In SBML Level 2 Version 4 and in Level
    3, the attribute 'useValuesFromTriggerTime' on Event was added  to
    allow a model to indicate the time at which the event's assignments
    are to be calculated, whether at the moment the event is triggered (if
    the value of the attribute is 'True),' or at the moment of execution
    (if 'useValuesFromTriggerTime'='False).'  If the event has a delay,
    the 'useValuesFromTriggerTime' is likely to make a significant
    difference in the values used in the assignment, but the possibility
    of simultaneous events mean that even zero-delay events can have
    different results depending on the value of this attribute.

    The definition of Event in SBML Level 2 Versions 1 and 2 includes an
    additional attribute called 'timeUnits', which allowed the time units
    of the Delay to be set explicitly.  Later Versions of SBML Level 2 as
    well as SBML Level 3 do not define this attribute.  LibSBML supports
    this attribute for compatibility with previous versions of SBML Level
    2; however, if a model in SBML Level 3 or Level 2 Versions 3-4 format
    sets the attribute, the consistency-checking method
    SBMLDocument.checkConsistency() will report an error.

    The attribute 'useValuesFromTriggerTime' was introduced in SBML Level
    2 Version 4.  Models defined in prior Versions of SBML Level 2 cannot
    use this attribute, and SBMLDocument.checkConsistency() will report an
    error if they do.

    SBML Level 3
    ......................................................................

    SBML Level 3 introduces several changes to the structure and
    components of Events compared to SBML Level 2.  These changes fall
    into two main categories: changes to what is optional or required, and
    additions of new attributes and elements.

    * The attribute 'useValuesFromTriggerTime' on Event is mandatory (it
    was optional in Level 2 and had a default value of 'True);'

    * Event's 'listOfEventAssignments' element (of class
    ListOfEventAssignments) is optional (it was mandatory in Level 2);

    * Event's 'priority' element (of class Priority) is new in Level 3;
    and

    * The Trigger object gains new mandatory attributes (described as
    part of the definition of Trigger).

    * In SBML Level 3 Version 2, the Trigger object became  optional.
    An Event with no Trigger will simply not fire. The changes to the
    attributes of Event are described below; the changes to Trigger and
    Priority are described in their respective sections.

    Semantics of events in SBML Level 3 Version 1
    ======================================================================

    The detailed semantics of events are described in the specification
    documents for each SBML Level/Version.  Here we include the
    description from the SBML Level 1 Version 1. Any transition of a
    Trigger object's 'math' formula from the value 'False' to 'True' will
    cause the enclosing Event object to trigger.  Such a transition is not
    possible at the very start of a simulation (i.e., at time t = 0)
    unless the Trigger object's 'initialValue' attribute has a value of
    'False;' this defines the value of the trigger formula to be 'False'
    immediately prior to the start of simulation, thereby giving it the
    potential to change in value from 'False' to 'True' when the formula
    is evaluated at t = 0.  If 'initialValue'='True,' then the trigger
    expression cannot transition from 'False' to 'True' at t = 0 but may
    do so at some time t > 0.

    Consider an Event object definition E with delay d in which the
    Trigger object's 'math' formula makes a transition in value from
    'False' to 'True' at times t_1 and t_2.  The EventAssignment within
    the Event object will have effect at t_1 + d and t_2 + d irrespective
    of the relative times of t_1 and t_2.  For example, events can
    'overlap' so that t_1 < t_2 < t_1 + d still causes an event
    assignments to occur at t_1 + d and t_2 + d.

    It is entirely possible for two events to be executed simultaneously,
    and it is possible for events to trigger other events (i.e., an event
    assignment can cause an event to trigger).  This leads to several
    points:

    * A software package should retest all event triggers after executing
    an event assignment in order to account for the possibility that the
    assignment causes another event trigger to transition from 'False' to
    'True.'  This check should be made after each individual Event
    object's execution, even when several events are to be executed
    simultaneously.

    * Any Event object whose Trigger 'persistent' attribute has the value
    'False' must have its trigger expression reevaluated continuously
    between when the event is triggered and when it is executed.  If its
    trigger expression ever evaluates to 'False,' it must be removed from
    the queue of events pending execution and treated as any other event
    whose trigger expression evaluates to 'False.'

    * Although the precise time at which events are executed is not
    resolved beyond the given execution point in simulated time, it is
    assumed that the order in which the events occur is resolved. This
    order can be significant in determining the overall outcome of a given
    simulation.  When an event X triggers another event Y and event Y has
    zero delay, then event Y is added to the existing set of simultaneous
    events that are pending execution.  Events X and Y form a cascade of
    events at the same point in simulation time.  An event such as Y may
    have a special priority if it contains a Priority subobject.

    * All events in a model are open to being in a cascade.  The position
    of an event in the event queue does not affect whether it can be in
    the cascade: event Y can be triggered whether it is before or after X
    in the queue of events pending execution.  A cascade of events can be
    potentially infinite (never terminate); when this occurs a simulator
    should indicate this has occurred---it is incorrect for a simulator to
    break a cascade arbitrarily and continue the simulation without at
    least indicating that the infinite cascade occurred.

    * Simultaneous events having no defined priorities are executed in an
    undefined order.  This does not mean that the behavior of the
    simulation is completely undefined; merely that the order of execution
    of these particular events is undefined.  A given simulator may use
    any algorithm to choose an order as long as every event is executed
    exactly once.

    * Events with defined priorities are executed in the order implied by
    their Priority 'math' formula values, with events having higher
    priorities being executed ahead of events with lower priorities, and
    events with identical priorities being executed in a random order with
    respect to one another (as determined at run-time by some random
    algorithm equivalent to coin-flipping).  Newly-triggered events that
    are to be executed immediately (i.e., if they define no delays) should
    be inserted into the queue of events pending execution according to
    their priorities: events with higher priority values value must be
    inserted ahead of events with lower priority values and after any
    pending events with even higher priorities, and inserted randomly
    among pending events with the same priority values.  Events without
    Priority objects must be inserted into the queue in some fashion, but
    the algorithm used to place it in the queue is undefined.  Similarly,
    there is no restriction on the order of a newly-inserted event with a
    defined Priority with respect to any other pending Event without a
    defined Priority.

    * A model variable that is the target of one or more event assignments
    can change more than once when simultaneous events are processed at
    some time point t.  The model's behavior (output) for such a variable
    is the value of the variable at the end of processing all the
    simultaneous events at time t.

    Restrictions relaxed in SBML Level 3 Version 2
    ======================================================================

    In SBML Level 3 Version 2, several restrictions were lifted  that have
    the potential to affect the semantics of an Event:

    * The Trigger subobject of an Event is optional.  If missing, an
    Event is never triggered, unless an alternate triggering  scheme is
    introduced by an SBML Level 3 package.

    * The 'math' subelements of an Event Trigger, Delay, Priority, and
    EventAssignment are all optional.  If any of these elements lack  a
    'math' subelement, and that information is not supplied in an SBML
    Level 3 package, it is mathematically equivalent to the Trigger,
    Delay, Priority, or EventAssignment not being present at all.

    * The ListOfEventAssignments may be empty, which is mathematically
    equivalent to the Event not having a ListOfEventAssignments at all.

    * Any 'math' subelement may return a Boolean or a numeric value in any
    context.  If a numeric value is used in a Boolean context, a '0' is
    interpreted as 'False,' and all other values are interpreted as
    'True.'  If a Boolean value is used in a numeric  context, a 'True' is
    interpreted as a 1, and a 'False' is  interpreted as a 0.  This means
    (for example) that a Trigger value  that changes from 0.0 to anything
    else is equivalent to changing  from 'False' to 'True.' See also
    Trigger, Priority, Delay, EventAssignment.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Event, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Event, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_Event
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(Event self, unsigned int level, unsigned int version) -> Event
        __init__(Event self, SBMLNamespaces sbmlns) -> Event
        __init__(Event self, Event orig) -> Event


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            Event(SBMLNamespaces sbmlns)

        Creates a new Event using the given SBMLNamespaces object 'sbmlns'.

        The SBMLNamespaces object encapsulates SBML Level/Version/namespaces
        information.  It is used to communicate the SBML Level, Version, and
        (in Level 3) packages used in addition to SBML Level 3 Core.  A common
        approach to using libSBML's SBMLNamespaces facilities is to create an
        SBMLNamespaces object somewhere in a program once, then hand that
        object as needed to object constructors that accept SBMLNamespaces as
        arguments.

        Parameter 'sbmlns' is an SBMLNamespaces object.

        Throws SBMLConstructorException: Thrown if the given 'sbmlns' is
        inconsistent or incompatible with this object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            Event(long level, long version)

        Creates a new Event using the given SBML 'level' and 'version' values.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        Event.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this Event.

        Throws SBMLConstructorException: Thrown if the given 'level' and
        'version' combination are invalid or if this object is incompatible
        with the given level and version.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            Event(Event orig)

        Copy constructor; creates a copy of this Event.

        Parameter 'orig' is the object to copy.

        """
        this = _libsbml.new_Event(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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


        Creates and returns a deep copy of this Event object.

        Returns the (deep) copy of this Event object.

        """
        return _libsbml.Event_clone(self)


    def initDefaults(self):
        """
        initDefaults(Event self)


        Initializes the fields of this Event object to 'typical' default
        values.

        The SBML Event component has slightly different aspects and default
        attribute values in different SBML Levels and Versions. This method
        sets the values to certain common defaults, based mostly on what they
        are in SBML Level 2.  Specifically:

        * Sets attribute 'useValuesFromTriggerTime' to 'True'

        """
        return _libsbml.Event_initDefaults(self)


    def getElementBySId(self, id):
        """
        getElementBySId(Event self, string id) -> SBase


        Returns the first child element found that has the given 'id' in the
        model-wide SId namespace, or 'None' if no such object is found.

        Parameter 'id' is string representing the id of the object to find.

        Returns pointer to the first element found with the given 'id'.

        """
        return _libsbml.Event_getElementBySId(self, id)


    def getElementByMetaId(self, metaid):
        """
        getElementByMetaId(Event self, string metaid) -> SBase


        Returns the first child element it can find with the given 'metaid',
        or 'None' if no such object is found.

        Parameter 'metaid' is string representing the metaid of the object to
        find.

        Returns pointer to the first element found with the given 'metaid'.

        """
        return _libsbml.Event_getElementByMetaId(self, metaid)


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


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

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is now recommended to use the
        getIdAttribute() function instead.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns the id of this Event.

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.Event_getId(self)


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


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

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns the name of this SBML object, or the empty string if not set
        or unsettable.

        See also getIdAttribute(), isSetName(), setName(), unsetName().

        """
        return _libsbml.Event_getName(self)


    def getTrigger(self, *args):
        """
        getTrigger(Event self) -> Trigger
        getTrigger(Event self) -> Trigger


        Get the event trigger portion of this Event.

        Returns the Trigger object of this Event, or 'None' if the trigger is
        not set.

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


    def getDelay(self, *args):
        """
        getDelay(Event self) -> Delay
        getDelay(Event self) -> Delay


        Get the assignment delay portion of this Event, if there is one.

        Returns the delay of this Event if one is defined, or 'None' if none
        is defined.

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


    def getPriority(self, *args):
        """
        getPriority(Event self) -> Priority
        getPriority(Event self) -> Priority


        (SBML Level 3 only) Get the event priority portion of this Event.

        Returns the Priority object of this Event, or 'None' if the Priority
        has not been set.

        Note: The element 'priority' is available in SBML Level 3, but is not
        present in lower Levels of SBML.

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


    def getTimeUnits(self):
        """
        getTimeUnits(Event self) -> string


        Get the value of the 'timeUnits' attribute of this Event, if it has
        one.

        Returns the value of the attribute 'timeUnits' as a string.

        WARNING:

        Definitions of Event in SBML Level 2 Versions 1 and 2 included the
        additional attribute called 'timeUnits', but it was removed in SBML
        Level 2 Version 3. LibSBML supports this attribute for compatibility
        with previous versions of SBML Level 2, but its use is discouraged
        since models in Level 2 Versions 3 and 4 cannot contain it.  If a
        Version 3 or 4 model sets the attribute, the consistency-checking
        method SBMLDocument.checkConsistency() will report an error.

        """
        return _libsbml.Event_getTimeUnits(self)


    def getUseValuesFromTriggerTime(self):
        """
        getUseValuesFromTriggerTime(Event self) -> bool


        Get the value of the 'useValuesFromTriggerTime' attribute of this
        Event.

        The optional Delay on Event and the fact that multiple events may be
        simultaneously executed means there are two times to consider when
        computing the results of an event: the time at which the event is
        triggered, and the time at which assignments are executed.  It is also
        possible to distinguish between the time at which the
        EventAssignment's expression is calculated, and the time at which the
        assignment is made: the expression could be evaluated at the same time
        the assignments are performed, i.e., when the event is executed, but
        it could also be defined to be evaluated at the time the event is
        triggered.

        In SBML Level 2 versions prior to Version 4, the semantics of Event
        time delays were defined such that the expressions in the event's
        assignments were always evaluated at the time the event was triggered.
        This definition made it difficult to define an event whose assignment
        formulas were meant to be evaluated at the time the event was executed
        (i.e., after the time period defined by the value of the Delay
        element, or after any other simultaneous event may have been executed
        and changed the model state). In SBML Level 2 Version 4, the attribute
        'useValuesFromTriggerTime' on Event allows a model to indicate the
        time at which the event's assignments are intended to be evaluated.
        In SBML Level 2, the attribute has a default value of 'True,' which
        corresponds to the interpretation of event assignments prior to
        Version 4: the values of the assignment formulas are computed at the
        moment the event is triggered, not after the delay.  If
        'useValuesFromTriggerTime'='False,' it means that the formulas in the
        event's assignments are to be computed after the delay, at the time
        the event is executed.  In SBML Level 3, the attribute is mandatory,
        not optional, and all events must specify a value for it.

        Returns the value of the attribute 'useValuesFromTriggerTime' as a
        boolean.

        WARNING:

        The attribute 'useValuesFromTriggerTime' was introduced in SBML Level
        2 Version 4.  It is not valid in models defined using SBML Level 2
        versions prior to Version 4. If a Level 2 Version 1-3 model sets the
        attribute, the consistency-checking method
        SBMLDocument.checkConsistency() will report an error.

        """
        return _libsbml.Event_getUseValuesFromTriggerTime(self)


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


        Predicate returning 'True' if this Event's 'id' attribute is set.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns 'True' if the 'id' attribute of this SBML object is set,
        'False' otherwise.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is recommended that callers use
        isSetIdAttribute() instead.

        See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(),
        isSetIdAttribute().

        """
        return _libsbml.Event_isSetId(self)


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


        Predicate returning 'True' if this Event's 'name' attribute is set.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns 'True' if the 'name' attribute of this SBML object is set,
        'False' otherwise.

        See also getName(), setName(), unsetName().

        """
        return _libsbml.Event_isSetName(self)


    def isSetTrigger(self):
        """
        isSetTrigger(Event self) -> bool


        Predicate for testing whether the trigger for this Event is set.

        Returns 'True' if the trigger of this Event is set, 'False' otherwise.

        """
        return _libsbml.Event_isSetTrigger(self)


    def isSetDelay(self):
        """
        isSetDelay(Event self) -> bool


        Predicate for testing whether the delay for this Event is set.

        Returns 'True' if the delay of this Event is set, 'False' otherwise.

        """
        return _libsbml.Event_isSetDelay(self)


    def isSetPriority(self):
        """
        isSetPriority(Event self) -> bool


        (SBML Level 3 only) Predicate for testing whether the priority for
        this Event is set.

        Returns 'True' if the priority of this Event is set, 'False'
        otherwise.

        Note: The element 'priority' is available in SBML Level 3, but is not
        present in lower Levels of SBML.

        """
        return _libsbml.Event_isSetPriority(self)


    def isSetTimeUnits(self):
        """
        isSetTimeUnits(Event self) -> bool


        Predicate for testing whether the 'timeUnits' attribute of this Event
        is set.

        Returns 'True' if the 'timeUnits' attribute of this Event is set,
        'False' otherwise.

        WARNING:

        Definitions of Event in SBML Level 2 Versions 1 and 2 included the
        additional attribute called 'timeUnits', but it was removed in SBML
        Level 2 Version 3. LibSBML supports this attribute for compatibility
        with previous versions of SBML Level 2, but its use is discouraged
        since models in Level 2 Versions 3 and 4 cannot contain it.  If a
        Version 3 or 4 model sets the attribute, the consistency-checking
        method SBMLDocument.checkConsistency() will report an error.

        """
        return _libsbml.Event_isSetTimeUnits(self)


    def isSetUseValuesFromTriggerTime(self):
        """
        isSetUseValuesFromTriggerTime(Event self) -> bool


        Predicate for testing whether the 'useValuesFromTriggerTime' attribute
        of this Event is set.

        Returns 'True' if the 'useValuesFromTriggerTime' attribute of this
        Event is set, 'False' otherwise.

        Note: In SBML Level 2, this attribute is optional and has a default
        value of 'True,' whereas in Level 3, this optional is mandatory and
        has no default value.

        """
        return _libsbml.Event_isSetUseValuesFromTriggerTime(self)


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


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

        The string 'sid' is copied.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Parameter 'sid' is the string to use as the identifier of this object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.Event_setId(self, sid)


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


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

        The string in 'name' is copied.

        Parameter 'name' is the new name for the SBML object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Event_setName(self, name)


    def setTrigger(self, trigger):
        """
        setTrigger(Event self, Trigger trigger) -> int


        Sets the trigger definition of this Event to a copy of the given
        Trigger object instance.

        Parameter 'trigger' is the Trigger object instance to use.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        """
        return _libsbml.Event_setTrigger(self, trigger)


    def setDelay(self, delay):
        """
        setDelay(Event self, Delay delay) -> int


        Sets the delay definition of this Event to a copy of the given Delay
        object instance.

        Parameter 'delay' is the Delay object instance to use.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        """
        return _libsbml.Event_setDelay(self, delay)


    def setPriority(self, priority):
        """
        setPriority(Event self, Priority priority) -> int


        (SBML Level 3 only) Sets the priority definition of this Event to a
        copy of the given Priority object instance.

        Parameter 'priority' is the Priority object instance to use.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        Note: The element 'priority' is available in SBML Level 3, but is not
        present in lower Levels of SBML.

        """
        return _libsbml.Event_setPriority(self, priority)


    def setTimeUnits(self, sid):
        """
        setTimeUnits(Event self, string sid) -> int


        Sets the 'timeUnits' attribute of this Event to a copy of 'sid'.

        Parameter 'sid' is the identifier of the time units to use.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        WARNING:

        Definitions of Event in SBML Level 2 Versions 1 and 2 included the
        additional attribute called 'timeUnits', but it was removed in SBML
        Level 2 Version 3. LibSBML supports this attribute for compatibility
        with previous versions of SBML Level 2, but its use is discouraged
        since models in Level 2 Versions 3 and 4 cannot contain it.  If a
        Version 3 or 4 model sets the attribute, the consistency-checking
        method SBMLDocument.checkConsistency() will report an error.

        """
        return _libsbml.Event_setTimeUnits(self, sid)


    def setUseValuesFromTriggerTime(self, value):
        """
        setUseValuesFromTriggerTime(Event self, bool value) -> int


        Sets the 'useValuesFromTriggerTime' attribute of this Event to a
        'value'.

        The optional Delay on Event and the fact that multiple events may be
        simultaneously executed means there are two times to consider when
        computing the results of an event: the time at which the event is
        triggered, and the time at which assignments are executed.  It is also
        possible to distinguish between the time at which the
        EventAssignment's expression is calculated, and the time at which the
        assignment is made: the expression could be evaluated at the same time
        the assignments are performed, i.e., when the event is executed, but
        it could also be defined to be evaluated at the time the event is
        triggered.

        In SBML Level 2 versions prior to Version 4, the semantics of Event
        time delays were defined such that the expressions in the event's
        assignments were always evaluated at the time the event was triggered.
        This definition made it difficult to define an event whose assignment
        formulas were meant to be evaluated at the time the event was executed
        (i.e., after the time period defined by the value of the Delay
        element, or after any other simultaneous event may have been executed
        and changed the model state). In SBML Level 2 Version 4, the attribute
        'useValuesFromTriggerTime' on Event allows a model to indicate the
        time at which the event's assignments are intended to be evaluated.
        In SBML Level 2, the attribute has a default value of 'True,' which
        corresponds to the interpretation of event assignments prior to
        Version 4: the values of the assignment formulas are computed at the
        moment the event is triggered, not after the delay.  If
        'useValuesFromTriggerTime'='False,' it means that the formulas in the
        event's assignments are to be computed after the delay, at the time
        the event is executed.  In SBML Level 3, the attribute is mandatory,
        not optional, and all events must specify a value for it.

        Parameter 'value' is the value of useValuesFromTriggerTime to use.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        WARNING:

        The attribute 'useValuesFromTriggerTime' was introduced in SBML Level
        2 Version 4.  It is not valid in models defined using SBML Level 2
        versions prior to Version 4. If a Level 2 Version 1-3 model sets the
        attribute, the consistency-checking method
        SBMLDocument.checkConsistency() will report an error.

        """
        return _libsbml.Event_setUseValuesFromTriggerTime(self, value)


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


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

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.Event_unsetId(self)


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


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

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getName(), setName(), isSetName().

        """
        return _libsbml.Event_unsetName(self)


    def unsetUseValuesFromTriggerTime(self):
        """
        unsetUseValuesFromTriggerTime(Event self) -> int


        Unsets the value of the 'useValuesFromTriggerTime' attribute of this
        Event.

        The optional Delay on Event and the fact that multiple events may be
        simultaneously executed means there are two times to consider when
        computing the results of an event: the time at which the event is
        triggered, and the time at which assignments are executed.  It is also
        possible to distinguish between the time at which the
        EventAssignment's expression is calculated, and the time at which the
        assignment is made: the expression could be evaluated at the same time
        the assignments are performed, i.e., when the event is executed, but
        it could also be defined to be evaluated at the time the event is
        triggered.

        In SBML Level 2 versions prior to Version 4, the semantics of Event
        time delays were defined such that the expressions in the event's
        assignments were always evaluated at the time the event was triggered.
        This definition made it difficult to define an event whose assignment
        formulas were meant to be evaluated at the time the event was executed
        (i.e., after the time period defined by the value of the Delay
        element, or after any other simultaneous event may have been executed
        and changed the model state). In SBML Level 2 Version 4, the attribute
        'useValuesFromTriggerTime' on Event allows a model to indicate the
        time at which the event's assignments are intended to be evaluated.
        In SBML Level 2, the attribute has a default value of 'True,' which
        corresponds to the interpretation of event assignments prior to
        Version 4: the values of the assignment formulas are computed at the
        moment the event is triggered, not after the delay.  If
        'useValuesFromTriggerTime'='False,' it means that the formulas in the
        event's assignments are to be computed after the delay, at the time
        the event is executed.  In SBML Level 3, the attribute is mandatory,
        not optional, and all events must specify a value for it.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        WARNING:

        The attribute 'useValuesFromTriggerTime' was introduced in SBML Level
        2 Version 4.  It is not valid in models defined using SBML Level 2
        versions prior to Version 4. If a Level 2 Version 1-3 model sets the
        attribute, the consistency-checking method
        SBMLDocument.checkConsistency() will report an error.

        """
        return _libsbml.Event_unsetUseValuesFromTriggerTime(self)


    def unsetDelay(self):
        """
        unsetDelay(Event self) -> int


        Unsets the Delay of this Event.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Event_unsetDelay(self)


    def unsetPriority(self):
        """
        unsetPriority(Event self) -> int


        (SBML Level 3 only) Unsets the Priority of this Event.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        Note: The element 'priority' is available in SBML Level 3, but is not
        present in lower Levels of SBML.

        """
        return _libsbml.Event_unsetPriority(self)


    def unsetTrigger(self):
        """
        unsetTrigger(Event self) -> int


        Unsets the Trigger of this Event.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        Note: The element 'priority' is available in SBML Level 3, but is not
        present in lower Levels of SBML.

        """
        return _libsbml.Event_unsetTrigger(self)


    def unsetTimeUnits(self):
        """
        unsetTimeUnits(Event self) -> int


        Unsets the 'timeUnits' attribute of this Event.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        * LIBSBML_OPERATION_FAILED

        WARNING:

        Definitions of Event in SBML Level 2 Versions 1 and 2 included the
        additional attribute called 'timeUnits', but it was removed in SBML
        Level 2 Version 3. LibSBML supports this attribute for compatibility
        with previous versions of SBML Level 2, but its use is discouraged
        since models in Level 2 Versions 3 and 4 cannot contain it.  If a
        Version 3 or 4 model sets the attribute, the consistency-checking
        method SBMLDocument.checkConsistency() will report an error.

        """
        return _libsbml.Event_unsetTimeUnits(self)


    def addEventAssignment(self, ea):
        """
        addEventAssignment(Event self, EventAssignment ea) -> int


        Appends a copy of the given EventAssignment to this Event.

        Parameter 'ea' is the EventAssignment object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_DUPLICATE_OBJECT_ID

        * LIBSBML_OPERATION_FAILED

        Note: This method should be used with some caution.  The fact that
        this method copies the object passed to it means that the caller will
        be left holding a physically different object instance than the one
        contained inside this object.  Changes made to the original object
        instance (such as resetting attribute values) will not affect the
        instance in this object.  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 other methods on this class
        (particularly a corresponding method whose name begins with the word
        create) for alternatives that do not lead to these issues.

        See also createEventAssignment().

        """
        return _libsbml.Event_addEventAssignment(self, ea)


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


        Creates a new, empty EventAssignment, adds it to this Event's list of
        event assignments and returns the EventAssignment.

        Returns the newly created EventAssignment object instance.

        See also addEventAssignment().

        """
        return _libsbml.Event_createEventAssignment(self)


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


        Creates a new, empty Trigger, adds it to this Event and  returns the
        Trigger.

        Returns the newly created Trigger object instance.

        """
        return _libsbml.Event_createTrigger(self)


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


        Creates a new, empty Delay, adds it to this Event and  returns the
        Delay.

        Returns the newly created Delay object instance.

        """
        return _libsbml.Event_createDelay(self)


    def createPriority(self):
        """
        createPriority(Event self) -> Priority


        (SBML Level 3 only) Creates a new, empty Priority, adds it to this
        Event and returns the Priority.

        Returns the newly created Priority object instance, or 'None' if the
        SBML level and version used for this Event does not define Priority
        children.

        Note: The element 'priority' is available in SBML Level 3, but is not
        present in lower Levels of SBML.

        """
        return _libsbml.Event_createPriority(self)


    def getListOfEventAssignments(self, *args):
        """
        getListOfEventAssignments(Event self) -> ListOfEventAssignments
        getListOfEventAssignments(Event self) -> ListOfEventAssignments


        Returns the list of event assignments for this Event.

        Returns the list of EventAssignments for this Event.

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


    def getEventAssignment(self, *args):
        """
        getEventAssignment(Event self, unsigned int n) -> EventAssignment
        getEventAssignment(Event self, unsigned int n) -> EventAssignment
        getEventAssignment(Event self, string variable) -> EventAssignment
        getEventAssignment(Event self, string variable) -> EventAssignment


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getEventAssignment(string variable)

        Return the event assignment indicated by the given 'variable'.

        Parameter 'variable' is a string, the identifier of the variable whose
        EventAssignment is being sought.

        Returns the EventAssignment for the given 'variable', or 'None' if no
        such EventAssignment exists.

        ______________________________________________________________________
        Method variant with the following signature:

            getEventAssignment(long n)

        Return a specific EventAssignment object of this Event.

        Parameter 'n' is an integer, the index of the EventAssignment object
        to return.

        Returns the nth EventAssignment of this Event.

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


    def getNumEventAssignments(self):
        """
        getNumEventAssignments(Event self) -> unsigned int


        Returns the number of EventAssignment objects attached to this Event.

        Returns the number of EventAssignments in this Event.

        """
        return _libsbml.Event_getNumEventAssignments(self)


    def removeEventAssignment(self, *args):
        """
        removeEventAssignment(Event self, unsigned int n) -> EventAssignment
        removeEventAssignment(Event self, string variable) -> EventAssignment


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeEventAssignment(string variable)

        Removes the EventAssignment object with the given 'variable' attribute
        from this Event object and returns a pointer to it.

        The caller owns the returned object and is responsible for deleting
        it. If none of the EventAssignment objects in this Event object have
        the  'variable' attribute 'variable', then 'None' is returned.

        Parameter 'variable' is the 'variable' attribute of the
        EventAssignment object  to remove.

        Returns the EventAssignment object removed.  As mentioned above, the
        caller owns the returned object. 'None' is returned if no
        EventAssignment object with the 'variable' attribute exists in this
        Event object.

        ______________________________________________________________________
        Method variant with the following signature:

            removeEventAssignment(long n)

        Removes the nth EventAssignment object from this Event object and
        returns a pointer to it.

        The caller owns the returned object and is responsible for deleting
        it.

        Parameter 'n' is the index of the EventAssignment object to remove.

        Returns the EventAssignment object removed.  As mentioned above,  the
        caller owns the returned item. 'None' is returned if the given index
        is out of range.

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


    def connectToChild(self):
        """connectToChild(Event self)"""
        return _libsbml.Event_connectToChild(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(Event self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.Event_enablePackageInternal(self, pkgURI, pkgPrefix, flag)


    def updateSBMLNamespace(self, package, level, version):
        """
        updateSBMLNamespace(Event self, string package, unsigned int level, unsigned int version)


        Internal implementation method.

        """
        return _libsbml.Event_updateSBMLNamespace(self, package, level, version)


    def getTypeCode(self):
        """
        getTypeCode(Event self) -> int


        Returns the libSBML type code of this object instance.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_EVENT (default).

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.Event_getTypeCode(self)


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


        Returns the XML element name of this object, which for Event, is
        always ''event'.'

        Returns the name of this element, i.e., ''event'.'

        """
        return _libsbml.Event_getElementName(self)


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


        Predicate returning 'True' if all the required attributes for this
        Event object have been set.

        The required attributes for an Event object are:

        * 'useValuesfromTriggerTime' (required in SBML Level 3)

        Returns 'True' if the required attributes have been set, 'False'
        otherwise.

        """
        return _libsbml.Event_hasRequiredAttributes(self)


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


        Predicate returning 'True' if all the required elements for this Event
        object have been set.

        Note: The required elements for an Event object are:

        * 'trigger' (required in SBML Level 2 and Level 3 Version 1;
        optional in SBML Level 3 Version 2+

        * 'listOfEventAssignments' (required in SBML Level 2; optional in
        Level 3)

        """
        return _libsbml.Event_hasRequiredElements(self)

Event_swigregister = _libsbml.Event_swigregister
Event_swigregister(Event)

class ListOfEvents(ListOf):
    """

    A list of Event objects.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfEvents, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfEvents, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ListOfEvents self, unsigned int level, unsigned int version) -> ListOfEvents
        __init__(ListOfEvents self, SBMLNamespaces sbmlns) -> ListOfEvents


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfEvents(SBMLNamespaces sbmlns)

        Creates a new ListOfEvents object.

        The object is constructed such that it is valid for the SBML Level and
        Version combination determined by the SBMLNamespaces object in
        'sbmlns'.

        Parameter 'sbmlns' is an SBMLNamespaces object that is used to
        determine the characteristics of the ListOfEvents object to be
        created.

        Throws SBMLConstructorException: Thrown if the given 'sbmlns' is
        inconsistent or incompatible with this object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfEvents(long level, long version)

        Creates a new ListOfEvents object.

        The object is constructed such that it is valid for the given SBML
        Level and Version combination.

        Parameter 'level' is the SBML Level.

        Parameter 'version' is the Version within the SBML Level.

        Throws SBMLConstructorException: Thrown if the given 'level' and
        'version' combination are invalid or if this object is incompatible
        with the given level and version.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        """
        this = _libsbml.new_ListOfEvents(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ListOfEvents self) -> ListOfEvents


        Creates and returns a deep copy of this ListOfEvents object.

        Returns the (deep) copy of this ListOfEvents object.

        """
        return _libsbml.ListOfEvents_clone(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfEvents self) -> int


        Returns the libSBML type code for the objects contained in this ListOf
        (i.e., Event objects, if the list is non-empty).

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for the objects contained in this ListOf:
        SBML_EVENT (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfEvents_getItemTypeCode(self)


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


        Returns the XML element name of this object.

        For ListOfEvents, the XML element name is ''listOfEvents'.'

        Returns the name of this element, i.e., ''listOfEvents'.'

        """
        return _libsbml.ListOfEvents_getElementName(self)


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get an Event from the ListOfEvents.

        Parameter 'n' is the index number of the Event to get.

        Returns the nth Event in this ListOfEvents.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get an Event from the ListOfEvents based on its identifier.

        Parameter 'sid' is a string representing the identifier  of the Event
        to get.

        Returns Event in this ListOfEvents with the given 'sid' or 'None' if
        no such Event exists.

        See also get(), size().

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


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


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth item from this ListOfEvents items and returns a
        pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the item to remove.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes item in this ListOfEvents 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 'sid', then
        'None' is returned.

        Parameter 'sid' is the identifier of the item to remove.

        Returns the item removed.  As mentioned above, the caller owns the
        returned item.

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

    __swig_destroy__ = _libsbml.delete_ListOfEvents
    __del__ = lambda self: None
ListOfEvents_swigregister = _libsbml.ListOfEvents_swigregister
ListOfEvents_swigregister(ListOfEvents)

class EventAssignment(SBase):
    """

    An assignment to a variable by an SBML event.

    Event contains an optional element called 'listOfEventAssignments', of
    class ListOfEventAssignments.  In every instance of an event
    definition in a model, the object's 'listOfEventAssignments' element
    must have a non-empty list of one or more 'eventAssignment' elements
    of class EventAssignment.  The object class EventAssignment has one
    required attribute, 'variable', and a required element, 'math'.  Being
    derived from SBase, it also has all the usual attributes and elements
    of its parent class.

    An Event object defines when the event can occur, the variables that
    are affected by the event, and how the variables are affected.  The
    purpose of the EventAssignment object class is to define how variables
    are affected by an Event.  In SBML Level 2, every Event object
    instance must have a nonempty list of event assignments; in SBML Level
    3, the list of assignments is optional.

    The operation of an Event is divided into two phases (regardless of
    whether a delay is involved): one phase when the event is triggered,
    and the other when the event is executed.   EventAssignment objects
    are interpreted when an event is executed.  The effects are described
    below.

    The attribute 'variable'
    ======================================================================

    The EventAssignment attribute 'variable' must be the identifier of an
    existing Compartment, Species, SpeciesReference, or Parameter instance
    defined in the model.  In SBML Level 3 Version 2, this list was
    expanded to include identifiers of SBML Level 3 package variables that
    have both mathematical meaning and the  ability to be assigned.  When
    the event is executed, the value of the model component identified by
    'variable' is changed by the EventAssignment to the value computed by
    the 'math' element; that is, a species' quantity, species reference's
    stoichiometry, compartment's size or parameter's value are reset to
    the value computed by 'math'.

    Certain restrictions are placed on what can appear in 'variable':

    * The object identified by the value of the EventAssignment attribute
    'variable' must not have its 'constant' attribute set to or default to
    'True.'  (Constants cannot be affected by events.)

    * The 'variable' attribute must not contain the identifier of a
    reaction.  In SBML Level 2 and SBML Level 3 Version 1, only species,
    species references, compartment and parameter values may be set by an
    Event.  In SBML Level 3 Version 2, the 'variable' attribute may also
    be the identifier of an SBML Level 3 package element with mathematical
    meaning and the ability to be assigned a value.  This situation may
    only arise if  the SBML package is present in the SBML document with a
    package:required attribute of 'True'

    * The value of every 'variable' attribute must be unique among the set
    of EventAssignment structures within a given Event structure.  In
    other words, a single event cannot have multiple EventAssignment
    objects assigning the same variable.  (All of them would be performed
    at the same time when that particular Event triggers, resulting in
    indeterminacy.)  However, separate Event instances can refer to the
    same variable.

    * A variable cannot be assigned a value in an EventAssignment object
    instance and also be assigned a value by an AssignmentRule; i.e., the
    value of an EventAssignment's 'variable' attribute cannot be the same
    as the value of a AssignmentRule' 'variable' attribute.  (Assignment
    rules hold at all times, therefore it would be inconsistent to also
    define an event that reassigns the value of the same variable.) If the
    variable attribute of an EventAssignment object references an  object
    in an SBML namespace that is not understood by the interpreter
    reading a given SBML document (that is, if the object is defined by an
    SBML Level 3 package that the software does not support), the  event
    assignment must be ignored--the object's value will not need to  be
    set, as the interpreter could not understand that package. If an
    interpreter cannot establish whether a referenced object is missing
    from the model or instead is defined in an SBML namespace not
    understood by the interpreter, it may produce a warning to the user.
    (The latter situation may only arise if an SBML package is present in
    the SBML document with a package:required attribute of 'true'.)

    Note that the time of assignment of the object identified by the value
    of the 'variable' attribute is always the time at which the Event is
    executed, not when it is triggered.  The timing is controlled by the
    optional Delay in an Event.  The time of assignment is not affected by
    the 'useValuesFromTriggerTime' attribute on Event---that attribute
    affects the time at which the EventAssignment's 'math' expression is
    evaluated.  In other words, SBML allows decoupling the time at which
    the 'variable' is assigned from the time at which its value expression
    is calculated.

    The 'math' subelement in an EventAssignment
    ======================================================================

    The MathML expression contained in an EventAssignment defines the new
    value of the variable being assigned by the Event.

    As mentioned above, the time at which the expression in 'math' is
    evaluated is determined by the attribute 'useValuesFromTriggerTime' on
    Event.  If the attribute value is 'True,' the expression must be
    evaluated when the event is triggered; more precisely, the values of
    identifiers occurring in MathML <ci> elements in the EventAssignment's
    'math' expression are the values they have at the point when the event
    triggered.  If, instead, 'useValuesFromTriggerTime''s value is
    'False,' it means the values at execution time should be used; that
    is, the values of identifiers occurring in MathML <ci> elements in the
    EventAssignment's 'math' expression are the values they have at the
    point when the event executed.

    SBML Level/Version differences
    ======================================================================

    Between Version 4 and previous versions of SBML Level 2, the
    requirements regarding the matching of units between an
    EvengAssignment's formula and the units of the object identified by
    the 'variable' attribute changed.  Previous versions required
    consistency, but in SBML Level 2 Version 4 and in SBML Level 3, unit
    consistency is only recommended.  More precisely:

    * In the case of a species, an EventAssignment sets the referenced
    species' quantity (concentration or amount of substance) to the value
    determined by the formula in the EventAssignment's 'math' subelement.
    The units of the 'math' formula should (in SBML Level 2 Version 4 and
    in Level 3) or must (in previous Versions of Level 2) be identical to
    the units of the species.

    * (SBML Level 3 only.) In the case of a species reference, an
    EventAssignment sets the stoichiometry of the reactant or product
    referenced by the SpeciesReference object to the value determined by
    the formula in the 'math' element.  The unit associated with the value
    produced by the 'math' formula should be 'dimensionless,' because
    reactant and product stoichiometries in reactions are dimensionless
    quantities.

    * In the case of a compartment, an EventAssignment sets the referenced
    compartment's size to the size determined by the formula in the 'math'
    subelement of the EventAssignment.  The overall units of the formula
    should (in SBML Level 2 Version 4 and in Level 3) or must (in previous
    Versions of Level 2) be identical to the units specified for the size
    of the compartment identified by the EventAssignment's 'variable'
    attribute.

    * In the case of a parameter, an EventAssignment sets the referenced
    parameter's value to that determined by the formula in 'math'.  The
    overall units of the formula should (in SBML Level 2 Version 4 and
    Level 3) or must (in previous Versions of Level 2) be identical to the
    units defined for the parameter.

    * (For SBML Level 3 Version 2 only) In the case of  an object from an
    SBML Level 3 package, an EventAssignment sets  the referenced object's
    value (as defined by that package) to the  value of the formula in
    'math'. The unit of measurement associated  with the value produced by
    the formula should be the same as that  object's units attribute value
    (if it has such an attribute), or be  equal to the units of model
    components of that type (if objects of  that class are defined by the
    package as having the same units). Note that the formula placed in the
    'math' element has no assumed units.  The consistency of the units of
    the formula, and the units of the entity which the assignment affects,
    must be explicitly established just as in the case of the value of the
    Delay subelement. An approach similar to the one discussed in the
    context of Delay may be used for the formula of an EventAssignment.

    Restrictions relaxed in SBML Level 3 Version 2
    ======================================================================

    In SBML Level 3 Version 2, the requirement that an EventAssignment
    have a 'math' subelement was relaxed, making it optional.  In this
    case, the EventAssignment remains undefined, and unless that
    information is provided in some other form (such as with an SBML Level
    3 package), the Event behaves as if it had no EventAssignment.

    See also Event.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, EventAssignment, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, EventAssignment, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_EventAssignment
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(EventAssignment self, unsigned int level, unsigned int version) -> EventAssignment
        __init__(EventAssignment self, SBMLNamespaces sbmlns) -> EventAssignment
        __init__(EventAssignment self, EventAssignment orig) -> EventAssignment


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            EventAssignment(SBMLNamespaces sbmlns)

        Creates a new EventAssignment using the given SBMLNamespaces object
        'sbmlns'.

        The SBMLNamespaces object encapsulates SBML Level/Version/namespaces
        information.  It is used to communicate the SBML Level, Version, and
        (in Level 3) packages used in addition to SBML Level 3 Core.  A common
        approach to using libSBML's SBMLNamespaces facilities is to create an
        SBMLNamespaces object somewhere in a program once, then hand that
        object as needed to object constructors that accept SBMLNamespaces as
        arguments.

        Parameter 'sbmlns' is an SBMLNamespaces object.

        Throws SBMLConstructorException: Thrown if the given 'sbmlns' is
        inconsistent or incompatible with this object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            EventAssignment(long level, long version)

        Creates a new EventAssignment using the given SBML 'level' and
        'version' values.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        EventAssignment.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this EventAssignment.

        Throws SBMLConstructorException: Thrown if the given 'level' and
        'version' combination are invalid or if this object is incompatible
        with the given level and version.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            EventAssignment(EventAssignment orig)

        Copy constructor; creates a copy of this EventAssignment.

        Parameter 'orig' is the object to copy.

        """
        this = _libsbml.new_EventAssignment(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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


        Creates and returns a deep copy of this EventAssignment object.

        Returns the (deep) copy of this EventAssignment object.

        """
        return _libsbml.EventAssignment_clone(self)


    def getVariable(self):
        """
        getVariable(EventAssignment self) -> string


        Get the value of this EventAssignment's 'variable' attribute.

        Returns the identifier stored in the 'variable' attribute of this
        EventAssignment.

        """
        return _libsbml.EventAssignment_getVariable(self)


    def getMath(self):
        """
        getMath(EventAssignment self) -> ASTNode


        Get the mathematical expression in this EventAssignment's 'math'
        subelement.

        Returns the top ASTNode of an abstract syntax tree representing the
        mathematical formula in this EventAssignment, or 'None' if the math is
        not set.

        """
        return _libsbml.EventAssignment_getMath(self)


    def isSetVariable(self):
        """
        isSetVariable(EventAssignment self) -> bool


        Predicate for testing whether the attribute 'variable' of this
        EventAssignment is set.

        Returns 'True' if the 'variable' attribute of this EventAssignment is
        set, 'False' otherwise.

        """
        return _libsbml.EventAssignment_isSetVariable(self)


    def isSetMath(self):
        """
        isSetMath(EventAssignment self) -> bool


        Predicate for testing whether the 'math' subelement of this
        EventAssignment is set.

        Returns 'True' if this EventAssignment has a 'math' subelement,
        'False' otherwise.

        """
        return _libsbml.EventAssignment_isSetMath(self)


    def setVariable(self, sid):
        """
        setVariable(EventAssignment self, string sid) -> int


        Sets the attribute 'variable' of this EventAssignment to a copy of the
        given identifier string.

        Parameter 'sid' is the identifier of an element defined in this model
        that can vary over time.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.EventAssignment_setVariable(self, sid)


    def unsetVariable(self):
        """
        unsetVariable(EventAssignment self) -> int


        Unsets the attribute 'variable' of this EventAssignment.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.EventAssignment_unsetVariable(self)


    def setMath(self, math):
        """
        setMath(EventAssignment self, ASTNode math) -> int


        Sets the 'math' subelement of this EventAssignment to a copy of the
        given ASTNode.

        Parameter 'math' is an ASTNode that will be copied and stored as the
        mathematical formula for this EventAssignment.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_OBJECT

        """
        return _libsbml.EventAssignment_setMath(self, math)


    def getDerivedUnitDefinition(self, *args):
        """
        getDerivedUnitDefinition(EventAssignment self) -> UnitDefinition
        getDerivedUnitDefinition(EventAssignment self) -> UnitDefinition


        Calculates and returns a UnitDefinition that expresses the units of
        measurement assumed for the 'math' expression of this EventAssignment.

        The units are calculated based on the mathematical expression in the
        EventAssignment and the model quantities referenced by <ci> elements
        used within that expression.  The method getDerivedUnitDefinition()
        returns the calculated units, to the extent that libSBML can compute
        them.

        Note: The functionality that facilitates unit analysis depends on the
        model as a whole.  Thus, in cases where the object has not been added
        to a model or the model itself is incomplete, unit analysis is not
        possible and this method will return 'None.'

        WARNING:

        Note that it is possible the 'math' expression in the EventAssignment
        contains literal numbers or parameters with undeclared units.  In
        those cases, it is not possible to calculate the units of the overall
        expression without making assumptions.  LibSBML does not make
        assumptions about the units, and getDerivedUnitDefinition() only
        returns the units as far as it is able to determine them.  For
        example, in an expression X + Y, if X has unambiguously-defined units
        and Y does not, it will return the units of X.  When using this
        method, it is critical that callers also invoke the method
        containsUndeclaredUnits() to determine whether this situation holds.
        Callers should take suitable action in those situations.

        Returns a UnitDefinition that expresses the units of the math
        expression of this EventAssignment, or 'None' if one cannot be
        constructed.

        See also containsUndeclaredUnits().

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


    def containsUndeclaredUnits(self, *args):
        """
        containsUndeclaredUnits(EventAssignment self) -> bool
        containsUndeclaredUnits(EventAssignment self) -> bool


        Predicate returning 'True' if the math expression of this
        EventAssignment contains literal numbers or parameters with undeclared
        units.

        The units are calculated based on the mathematical expression in the
        EventAssignment and the model quantities referenced by <ci> elements
        used within that expression.  The method getDerivedUnitDefinition()
        returns the calculated units, to the extent that libSBML can compute
        them.

        If the expression contains literal numbers or parameters with
        undeclared units, libSBML may not be able to compute the full units of
        the expression and will only return what it can compute.  Callers
        should always use containsUndeclaredUnits() when using
        getDerivedUnitDefinition() to decide whether the returned units may be
        incomplete.

        Returns 'True' if the math expression of this EventAssignment includes
        parameters/numbers  with undeclared units, 'False' otherwise.

        Note: A return value of 'True' indicates that the UnitDefinition
        returned by getDerivedUnitDefinition() may not accurately represent
        the units of the expression.

        See also getDerivedUnitDefinition().

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


    def getTypeCode(self):
        """
        getTypeCode(EventAssignment self) -> int


        Returns the libSBML type code of this object instance.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_EVENT_ASSIGNMENT
        (default).

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.EventAssignment_getTypeCode(self)


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


        Returns the XML element name of this object, which for
        EventAssignment, is always ''eventAssignment'.'

        Returns the name of this element, i.e., ''eventAssignment'.'

        """
        return _libsbml.EventAssignment_getElementName(self)


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


        Predicate returning 'True' if all the required attributes for this
        EventAssignment object have been set.

        The required attributes for a EventAssignment object are:

        * 'variable'

        Returns 'True' if the required attributes have been set, 'False'
        otherwise.

        """
        return _libsbml.EventAssignment_hasRequiredAttributes(self)


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


        Predicate returning 'True' if all the required elements for this
        EventAssignment object have been set.

        Note: The required elements for an EventAssignment object are:

        * 'math' in SBML Level 2 and Level 3 Version 1.   (In SBML Level 3
        Version 2+, it is no longer required.)

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

        """
        return _libsbml.EventAssignment_hasRequiredElements(self)


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


        Returns the value of the 'variable' attribute of this EventAssignment
        (NOT the 'id').

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is now recommended to use the
        getIdAttribute() or getVariable() instead.

        The 'variable' attribute of an EventAssignment indicates the element
        which the results of the 'math' are to be applied upon Event
        execution.

        Returns the variable of this EventAssignment.

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute(), getVariable().

        """
        return _libsbml.EventAssignment_getId(self)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(EventAssignment self, string oldid, string newid)


        Replaces all uses of a given 'SIdRef' type attribute value with
        another value.

        In SBML, object identifiers are of a data type called SId. In SBML
        Level 3, an explicit data type called SIdRef was introduced for
        attribute values that refer to SId values; in previous Levels of SBML,
        this data type did not exist and attributes were simply described to
        as 'referring to an identifier', but the effective data type was the
        same as SIdRef in Level 3.  These and other methods of libSBML refer
        to the type SIdRef for all Levels of SBML, even if the corresponding
        SBML specification did not explicitly name the data type.

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas in MathML content, comparing the referenced
        identifiers to the value of 'oldid'.  If any matches are found, the
        matching values are replaced with 'newid'.  The method does not
        descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.EventAssignment_renameSIdRefs(self, oldid, newid)


    def renameUnitSIdRefs(self, oldid, newid):
        """
        renameUnitSIdRefs(EventAssignment self, string oldid, string newid)


        Replaces all uses of a given 'UnitSIdRef' type attribute value with
        another value.

        In SBML, unit definitions have identifiers of type UnitSId.  In SBML
        Level 3, an explicit data type called UnitSIdRef was introduced for
        attribute values that refer to UnitSId values; in previous Levels of
        SBML, this data type did not exist and attributes were simply
        described to as 'referring to a unit identifier', but the effective
        data type was the same as UnitSIdRef in Level 3.  These and other
        methods of libSBML refer to the type UnitSIdRef for all Levels of
        SBML, even if the corresponding SBML specification did not explicitly
        name the data type.

        This method works by looking at all unit identifier attribute values
        (including, if appropriate, inside mathematical formulas), comparing
        the referenced unit identifiers to the value of 'oldid'.  If any
        matches are found, the matching values are replaced with 'newid'.  The
        method does not descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.EventAssignment_renameUnitSIdRefs(self, oldid, newid)


    def replaceSIDWithFunction(self, id, function):
        """
        replaceSIDWithFunction(EventAssignment self, string id, ASTNode function)


        Internal implementation method.

        """
        return _libsbml.EventAssignment_replaceSIDWithFunction(self, id, function)


    def divideAssignmentsToSIdByFunction(self, id, function):
        """
        divideAssignmentsToSIdByFunction(EventAssignment self, string id, ASTNode function)


        Internal implementation method.

        """
        return _libsbml.EventAssignment_divideAssignmentsToSIdByFunction(self, id, function)


    def multiplyAssignmentsToSIdByFunction(self, id, function):
        """
        multiplyAssignmentsToSIdByFunction(EventAssignment self, string id, ASTNode function)


        Internal implementation method.

        """
        return _libsbml.EventAssignment_multiplyAssignmentsToSIdByFunction(self, id, function)

EventAssignment_swigregister = _libsbml.EventAssignment_swigregister
EventAssignment_swigregister(EventAssignment)

class ListOfEventAssignments(ListOf):
    """

    A list of EventAssignment objects.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfEventAssignments, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfEventAssignments, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ListOfEventAssignments self, unsigned int level, unsigned int version) -> ListOfEventAssignments
        __init__(ListOfEventAssignments self, SBMLNamespaces sbmlns) -> ListOfEventAssignments


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfEventAssignments(SBMLNamespaces sbmlns)

        Creates a new ListOfEventAssignments object.

        The object is constructed such that it is valid for the SBML Level and
        Version combination determined by the SBMLNamespaces object in
        'sbmlns'.

        Parameter 'sbmlns' is an SBMLNamespaces object that is used to
        determine the characteristics of the ListOfEventAssignments object to
        be created.

        Throws SBMLConstructorException: Thrown if the given 'sbmlns' is
        inconsistent or incompatible with this object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfEventAssignments(long level, long version)

        Creates a new ListOfEventAssignments object.

        The object is constructed such that it is valid for the given SBML
        Level and Version combination.

        Parameter 'level' is the SBML Level.

        Parameter 'version' is the Version within the SBML Level.

        Throws SBMLConstructorException: Thrown if the given 'level' and
        'version' combination are invalid or if this object is incompatible
        with the given level and version.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        """
        this = _libsbml.new_ListOfEventAssignments(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ListOfEventAssignments self) -> ListOfEventAssignments


        Creates and returns a deep copy of this ListOfEventAssignments object.

        Returns the (deep) copy of this ListOfEventAssignments object.

        """
        return _libsbml.ListOfEventAssignments_clone(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfEventAssignments self) -> int


        Returns the libSBML type code for the objects contained in this ListOf
        (i.e., EventAssignment objects, if the list is non-empty).

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for the objects contained in this ListOf:
        SBML_EVENT_ASSIGNMENT (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfEventAssignments_getItemTypeCode(self)


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


        Returns the XML element name of this object.

        For ListOfEventAssignments, the XML element name is
        ''listOfEventAssignments'.'

        Returns the name of this element, i.e., ''listOfEventAssignments'.'

        """
        return _libsbml.ListOfEventAssignments_getElementName(self)


    def get(self, *args):
        """
        get(ListOfEventAssignments self, unsigned int n) -> EventAssignment
        get(ListOfEventAssignments self, unsigned int n) -> EventAssignment
        get(ListOfEventAssignments self, string sid) -> EventAssignment
        get(ListOfEventAssignments self, string sid) -> EventAssignment


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a EventAssignment from the ListOfEventAssignments.

        Parameter 'n' is the index number of the EventAssignment to get.

        Returns the nth EventAssignment in this ListOfEventAssignments. If the
        index 'n' is invalid, 'None' is returned.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a EventAssignment from the ListOfEventAssignments based on its
        identifier.

        Parameter 'sid' is a string representing the identifier  of the
        EventAssignment to get.

        Returns EventAssignment in this ListOfEventAssignments with the given
        'sid' or 'None' if no such EventAssignment exists.

        See also get(), size().

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


    def remove(self, *args):
        """
        remove(ListOfEventAssignments self, unsigned int n) -> EventAssignment
        remove(ListOfEventAssignments self, string sid) -> EventAssignment


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth item from this ListOfEventAssignments items and
        returns a pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the item to remove.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes item in this ListOfEventAssignments 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 'sid', then
        'None' is returned.

        Parameter 'sid' is the identifier of the item to remove.

        Returns the item removed.  As mentioned above, the caller owns the
        returned item.

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


    def getElementBySId(self, id):
        """
        getElementBySId(ListOfEventAssignments self, string id) -> SBase


        Returns the first child element found that has the given 'id' in the
        model-wide SId namespace, or 'None' if no such object is found.

        Note that EventAssignments do not actually have IDs, but the libsbml
        interface pretends that they do: no event assignment is returned by
        this function.

        Parameter 'id' is string representing the id of the object to find.

        Returns pointer to the first element found with the given 'id'.

        """
        return _libsbml.ListOfEventAssignments_getElementBySId(self, id)

    __swig_destroy__ = _libsbml.delete_ListOfEventAssignments
    __del__ = lambda self: None
ListOfEventAssignments_swigregister = _libsbml.ListOfEventAssignments_swigregister
ListOfEventAssignments_swigregister(ListOfEventAssignments)

class Trigger(SBase):
    """

    The trigger expression for an SBML event.

    An Event object defines when the event can occur, the variables that
    are affected by the event, and how the variables are affected.  The
    Trigger construct in SBML is used to define a mathematical expression
    that determines when an Event is triggered.

    A Trigger object in SBML Level 2 and Level 3 contains one subelement
    named 'math' containing a MathML expression.  The expression is
    evaluated as a value of type 'boolean.'  The exact moment at which the
    expression evaluates to 'True' is the time point when the Event is
    triggered.  In SBML Level 3, Trigger has additional attributes that
    must be assigned values; they are discussed in a separate section
    below.

    In SBML Level 2 and SBML Level 3 Version 1, the 'math' subelement is
    required, and it must evaluate to a 'boolean' expression. In SBML
    Level 3 Version 2, those restrictions are relaxed: the 'math' element
    is optional, and numeric values are allowed in  Boolean contexts (a
    '0' is interpreted as 'False,' and all other values are interpreted as
    'True).'  If a Trigger with no 'math' is present in an Event, that
    Event will never trigger, unless that missing information is included
    in an SBML Level 3 package.

    An event only triggers when its Trigger expression makes the
    transition in value from 'False' to 'True.'  The event will also
    trigger at any subsequent time points when the trigger makes this
    transition; in other words, an event can be triggered multiple times
    during a simulation if its trigger condition makes the transition from
    'False' to 'True' more than once.  In SBML Level 3, the behavior at
    the very start of simulation (i.e., at t = 0, where t stands for time)
    is determined in part by the boolean flag 'initialValue'.  This and
    other additional features introduced in SBML Level 3 are discussed
    further below.

    Version differences
    ======================================================================

    SBML Level 3 Version 1 introduces two required attributes on the
    Trigger object: 'persistent' and 'initialValue'.  The rest of this
    introduction describes these two attributes.

    The 'persistent' attribute on Trigger
    ......................................................................

    In the interval between when an Event object triggers (i.e., its
    Trigger object expression transitions in value from 'False' to 'True)'
    and when its assignments are to be executed, conditions in the model
    may change such that the trigger expression transitions back from
    'True' to 'False.'  Should the event's assignments still be made if
    this happens?  Answering this question is the purpose of the
    'persistent' attribute on Trigger.

    If the boolean attribute 'persistent' has a value of 'True,' then once
    the event is triggered, all of its assignments are always performed
    when the time of execution is reached.  The name persistent is meant
    to evoke the idea that the trigger expression does not have to be re-
    checked after it triggers if 'persistent'='True.'  Conversely, if the
    attribute value is 'False,' then the trigger expression is not assumed
    to persist: if the expression transitions in value back to 'False' at
    any time between when the event triggered and when it is to be
    executed, the event is no longer considered to have triggered and its
    assignments are not executed.  (If the trigger expression transitions
    once more to 'True' after that point, then the event is triggered, but
    this then constitutes a whole new event trigger-and-execute sequence.)

    The 'persistent' attribute can be especially useful when Event objects
    contain Delay objects, but it is relevant even in a model without
    delays if the model contains two or more events.  As explained in the
    introduction to this section, the operation of all events in SBML
    (delayed or not) is conceptually divided into two phases, triggering
    and execution; however, unless events have priorities associated with
    them, SBML does not mandate a particular ordering of event execution
    in the case of simultaneous events.  Models with multiple events can
    lead to situations where the execution of one event affects another
    event's trigger expression value.  If that other event has
    'persistent'='False,' and its trigger expression evaluates to 'False'
    before it is to be executed, the event must not be executed after all.

    The 'initialValue' attribute on Trigger
    ......................................................................

    As mentioned above, an event triggers when the mathematical expression
    in its Trigger object transitions in value from 'False' to 'True.'  An
    unanswered question concerns what happens at the start of a
    simulation: can event triggers make this transition at t = 0, where t
    stands for time?

    In order to determine whether an event may trigger at t = 0, it is
    necessary to know what value the Trigger object's 'math' expression
    had immediately prior to t = 0.  This starting value of the trigger
    expression is determined by the value of the boolean attribute
    'initialValue'.  A value of 'True' means the trigger expression is
    taken to have the value 'True' immediately prior to t = 0.  In that
    case, the trigger cannot transition in value from 'False' to 'True' at
    the moment simulation begins (because it has the value 'True' both
    before and after t = 0), and can only make the transition from 'False'
    to 'True' sometime after t = 0.  (To do that, it would also first have
    to transition to 'False' before it could make the transition from
    'False' back to 'True.)'  Conversely, if 'initialValue'='False,' then
    the trigger expression is assumed to start with the value 'False,' and
    therefore may trigger at t = 0 if the expression evaluates to 'True'
    at that moment.

    See also Event, Delay, EventAssignment.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Trigger, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Trigger, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_Trigger
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(Trigger self, unsigned int level, unsigned int version) -> Trigger
        __init__(Trigger self, SBMLNamespaces sbmlns) -> Trigger
        __init__(Trigger self, Trigger orig) -> Trigger


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            Trigger(SBMLNamespaces sbmlns)

        Creates a new Trigger using the given SBMLNamespaces object 'sbmlns'.

        The SBMLNamespaces object encapsulates SBML Level/Version/namespaces
        information.  It is used to communicate the SBML Level, Version, and
        (in Level 3) packages used in addition to SBML Level 3 Core.  A common
        approach to using libSBML's SBMLNamespaces facilities is to create an
        SBMLNamespaces object somewhere in a program once, then hand that
        object as needed to object constructors that accept SBMLNamespaces as
        arguments.

        Parameter 'sbmlns' is an SBMLNamespaces object.

        Throws SBMLConstructorException: Thrown if the given 'sbmlns' is
        inconsistent or incompatible with this object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            Trigger(long level, long version)

        Creates a new Trigger using the given SBML 'level' and 'version'
        values.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        Trigger.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this Trigger.

        Throws SBMLConstructorException: Thrown if the given 'level' and
        'version' combination are invalid or if this object is incompatible
        with the given level and version.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            Trigger(Trigger orig)

        Copy constructor; creates a copy of this Trigger.

        Parameter 'orig' is the object to copy.

        """
        this = _libsbml.new_Trigger(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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


        Creates and returns a deep copy of this Trigger object.

        Returns the (deep) copy of this Trigger object.

        """
        return _libsbml.Trigger_clone(self)


    def getMath(self):
        """
        getMath(Trigger self) -> ASTNode


        Get the mathematical formula for the trigger and return it as an AST.

        Returns the math of this Trigger, or 'None' if the math is not set.

        """
        return _libsbml.Trigger_getMath(self)


    def getInitialValue(self):
        """
        getInitialValue(Trigger self) -> bool


        (SBML Level 3 only) Get the value of the 'initialValue' attribute of
        this Trigger.

        Returns the boolean value stored as the 'initialValue' attribute value
        in this Trigger.

        Note: The attribute 'initialValue' is available in SBML Level 3, but
        is not present in lower Levels of SBML.

        """
        return _libsbml.Trigger_getInitialValue(self)


    def getPersistent(self):
        """
        getPersistent(Trigger self) -> bool


        (SBML Level 3 only) Get the value of the 'persistent' attribute of
        this Trigger.

        Returns the boolean value stored as the 'persistent' attribute value
        in this Trigger.

        Note: The attribute 'persistent' is available in SBML Level 3, but is
        not present in lower Levels of SBML.

        """
        return _libsbml.Trigger_getPersistent(self)


    def isSetMath(self):
        """
        isSetMath(Trigger self) -> bool


        Predicate to test whether the math for this trigger is set.

        Returns 'True' if the formula (meaning the 'math' subelement) of this
        Trigger is set, 'False' otherwise.

        """
        return _libsbml.Trigger_isSetMath(self)


    def isSetInitialValue(self):
        """
        isSetInitialValue(Trigger self) -> bool


        (SBML Level 3 only) Predicate to test whether the 'initialValue'
        attribute for this trigger is set.

        Returns 'True' if the initialValue attribute of this Trigger is set,
        'False' otherwise.

        Note: The attribute 'initialValue' is available in SBML Level 3, but
        is not present in lower Levels of SBML.

        """
        return _libsbml.Trigger_isSetInitialValue(self)


    def isSetPersistent(self):
        """
        isSetPersistent(Trigger self) -> bool


        (SBML Level 3 only) Predicate to test whether the 'persistent'
        attribute for this trigger is set.

        Returns 'True' if the persistent attribute of this Trigger is set,
        'False' otherwise.

        Note: The attribute 'persistent' is available in SBML Level 3, but is
        not present in lower Levels of SBML.

        """
        return _libsbml.Trigger_isSetPersistent(self)


    def setMath(self, math):
        """
        setMath(Trigger self, ASTNode math) -> int


        Sets the trigger expression of this Trigger instance to a copy of the
        given ASTNode.

        Parameter 'math' is an ASTNode representing a formula tree.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_OBJECT

        """
        return _libsbml.Trigger_setMath(self, math)


    def setInitialValue(self, initialValue):
        """
        setInitialValue(Trigger self, bool initialValue) -> int


        (SBML Level 3 only) Sets the 'initialValue' attribute of this Trigger
        instance.

        Parameter 'initialValue' is a boolean representing the initialValue to
        be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        Note: The attribute 'initialValue' is available in SBML Level 3, but
        is not present in lower Levels of SBML.

        """
        return _libsbml.Trigger_setInitialValue(self, initialValue)


    def setPersistent(self, persistent):
        """
        setPersistent(Trigger self, bool persistent) -> int


        (SBML Level 3 only) Sets the 'persistent' attribute of this Trigger
        instance.

        Parameter 'persistent' is a boolean representing the persistent value
        to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        Note: The attribute 'persistent' is available in SBML Level 3, but is
        not present in lower Levels of SBML.

        """
        return _libsbml.Trigger_setPersistent(self, persistent)


    def unsetInitialValue(self):
        """
        unsetInitialValue(Trigger self) -> int


        (SBML Level 3 only) Unsets the 'initialValue' attribute of this
        Trigger instance.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        Note: The attribute 'initialValue' is available in SBML Level 3, but
        is not present in lower Levels of SBML.

        """
        return _libsbml.Trigger_unsetInitialValue(self)


    def unsetPersistent(self):
        """
        unsetPersistent(Trigger self) -> int


        (SBML Level 3 only) Unsets the 'persistent' attribute of this  Trigger
        instance.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        Note: The attribute 'persistent' is available in SBML Level 3, but is
        not present in lower Levels of SBML.

        """
        return _libsbml.Trigger_unsetPersistent(self)


    def getTypeCode(self):
        """
        getTypeCode(Trigger self) -> int


        Returns the libSBML type code of this object instance.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_TRIGGER (default).

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.Trigger_getTypeCode(self)


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


        Returns the XML element name of this object, which for Trigger, is
        always ''trigger'.'

        Returns the name of this element, i.e., ''trigger'.'

        """
        return _libsbml.Trigger_getElementName(self)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(Trigger self, string oldid, string newid)


        Replaces all uses of a given 'SIdRef' type attribute value with
        another value.

        In SBML, object identifiers are of a data type called SId. In SBML
        Level 3, an explicit data type called SIdRef was introduced for
        attribute values that refer to SId values; in previous Levels of SBML,
        this data type did not exist and attributes were simply described to
        as 'referring to an identifier', but the effective data type was the
        same as SIdRef in Level 3.  These and other methods of libSBML refer
        to the type SIdRef for all Levels of SBML, even if the corresponding
        SBML specification did not explicitly name the data type.

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas in MathML content, comparing the referenced
        identifiers to the value of 'oldid'.  If any matches are found, the
        matching values are replaced with 'newid'.  The method does not
        descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.Trigger_renameSIdRefs(self, oldid, newid)


    def renameUnitSIdRefs(self, oldid, newid):
        """
        renameUnitSIdRefs(Trigger self, string oldid, string newid)


        Replaces all uses of a given 'UnitSIdRef' type attribute value with
        another value.

        In SBML, unit definitions have identifiers of type UnitSId.  In SBML
        Level 3, an explicit data type called UnitSIdRef was introduced for
        attribute values that refer to UnitSId values; in previous Levels of
        SBML, this data type did not exist and attributes were simply
        described to as 'referring to a unit identifier', but the effective
        data type was the same as UnitSIdRef in Level 3.  These and other
        methods of libSBML refer to the type UnitSIdRef for all Levels of
        SBML, even if the corresponding SBML specification did not explicitly
        name the data type.

        This method works by looking at all unit identifier attribute values
        (including, if appropriate, inside mathematical formulas), comparing
        the referenced unit identifiers to the value of 'oldid'.  If any
        matches are found, the matching values are replaced with 'newid'.  The
        method does not descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.Trigger_renameUnitSIdRefs(self, oldid, newid)


    def replaceSIDWithFunction(self, id, function):
        """
        replaceSIDWithFunction(Trigger self, string id, ASTNode function)


        Internal implementation method.

        """
        return _libsbml.Trigger_replaceSIDWithFunction(self, id, function)


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


        Predicate returning 'True' if all the required elements for this
        Trigger object have been set.

        Note: The required elements for a Trigger object are:

        * 'math' inSBML Level 2 and Level 3 Version 1.   (In SBML Level 3
        Version 2+, it is no longer required.)

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

        """
        return _libsbml.Trigger_hasRequiredElements(self)


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


        Predicate returning 'True' if all the required attributes for this
        Trigger object have been set.

        The required attributes for a Trigger object are:

        * 'persistent' (required in SBML Level 3)

        * 'initialValue' (required in SBML Level 3)

        Returns a boolean value indicating whether all the required attributes
        for this object have been defined.

        """
        return _libsbml.Trigger_hasRequiredAttributes(self)


    def removeFromParentAndDelete(self):
        """
        removeFromParentAndDelete(Trigger self) -> int


        Finds this Trigger's Event parent and calls unsetTrigger() on it,
        indirectly deleting itself.  Overridden from the SBase function since
        the parent is not a ListOf.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Trigger_removeFromParentAndDelete(self)

Trigger_swigregister = _libsbml.Trigger_swigregister
Trigger_swigregister(Trigger)

class Delay(SBase):
    """

    A delay on the time of execution of an SBML event.

    An Event object defines when the event can occur, the variables that
    are affected by the event, and how the variables are affected.  The
    effect of the event can optionally be delayed after the occurrence of
    the condition which invokes it.  An event delay is defined using an
    object of class Delay.

    The object class Delay is derived from SBase and adds a single
    subelement called 'math'.  This subelement is used to hold MathML
    content.  The mathematical formula represented by 'math' must evaluate
    to a numerical value.  It is used as the length of time between when
    the event is triggered and when the event's assignments are actually
    executed.  If no delay is present on a given Event, a time delay of
    zero is assumed.

    The expression in 'math' must be evaluated at the time the event is
    triggered.  The expression must always evaluate to a nonnegative
    number (otherwise, a nonsensical situation could arise where an event
    is defined to execute before it is triggered!).

    The units of the mathematical expression in a Delay
    ======================================================================

    In SBML Level 2 versions before Version 4, the units of the numerical
    value computed by the Delay's 'math' expression are required to be in
    units of time, or the model is considered to have a unit consistency
    error.  In Level 2 Version 4 as well as SBML Level 3, this requirement
    is relaxed; these specifications only stipulate that the units of the
    numerical value computed by a Delay instance's 'math' expression
    should match the model's units of time (meaning the definition of the
    'time' units in the model).  LibSBML respects these requirements, and
    depending on whether an earlier Version of SBML Level 2 is in use,
    libSBML may or may not flag unit inconsistencies as errors or merely
    warnings.

    Note that units are not predefined or assumed for the contents of
    'math' in a Delay object; rather, they must be defined explicitly for
    each instance of a Delay object in a model.  This is an important
    point to bear in mind when literal numbers are used in delay
    expressions.  For example, the following Event instance would result
    in a warning logged by SBMLDocument.checkConsistency() about the fact
    that libSBML cannot verify the consistency of the units of the
    expression.  The reason is that the formula inside the 'math' element
    does not have any declared units, whereas what is expected in this
    context is units of time:

      <model>
          ...
          <listOfEvents>
              <event useValuesFromTriggerTime='true'>
                  ...
                  <delay>
                      <math xmlns='http://www.w3.org/1998/Math/MathML'>
                          <cn> 1 </cn>
                      </math>
                  </delay>
                  ...
              </event>
          </listOfEvents>
          ...
      </model>

    The <cn> 1 </cn> within the mathematical formula of the 'delay' above
    has no units declared.  To make the expression have the needed units
    of time, literal numbers should be avoided in favor of defining
    Parameter objects for each quantity, and declaring units for the
    Parameter values.  The following fragment of SBML illustrates this
    approach:

      <model>
          ...
          <listOfParameters>
              <parameter id='transcriptionDelay' value='10' units='second'/>
          </listOfParameters>
          ...
          <listOfEvents>
              <event useValuesFromTriggerTime='true'>
                  ...
                  <delay>
                      <math xmlns='http://www.w3.org/1998/Math/MathML'>
                          <ci> transcriptionDelay </ci>
                      </math>
                  </delay>
                  ...
              </event>
          </listOfEvents>
          ...
      </model>

    In SBML Level 3, an alternative approach is available in the form of
    the 'units' attribute, which SBML Level 3 allows to appear on MathML
    'cn' elements.  The value of this attribute can be used to indicate
    the unit of measurement to be associated with the number in the
    content of a 'cn' element.  The attribute is named 'units' but,
    because it appears inside MathML element (which is in the XML
    namespace for MathML and not the namespace for SBML), it must always
    be prefixed with an XML namespace prefix for an SBML Level 3
    namespace.  The following is an example of this approach:

      <model timeUnits='second' ...>
          ...
          <listOfEvents>
              <event useValuesFromTriggerTime='true'>
                  ...
                  <delay>
                      <math xmlns='http://www.w3.org/1998/Math/MathML'
                            xmlns:sbml='http://www.sbml.org/sbml/level3/version1/core'>
                          <cn sbml:units='second'> 10 </cn>
                      </math>
                  </delay>
                  ...
              </event>
          </listOfEvents>
          ...
      </model>

    Restrictions relaxed in SBML Level 3 Version 2
    ======================================================================

    In SBML Level 3 Version 2, the requirement that a Delay have a 'math'
    subelement was relaxed, making it optional.  In this case, the Delay
    remains undefined, and unless that information is provided in some
    other form (such as with an SBML Level 3 package), the Event behaves
    as if it had no Delay.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Delay, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Delay, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_Delay
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(Delay self, unsigned int level, unsigned int version) -> Delay
        __init__(Delay self, SBMLNamespaces sbmlns) -> Delay
        __init__(Delay self, Delay orig) -> Delay


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            Delay(SBMLNamespaces sbmlns)

        Creates a new Delay using the given SBMLNamespaces object 'sbmlns'.

        The SBMLNamespaces object encapsulates SBML Level/Version/namespaces
        information.  It is used to communicate the SBML Level, Version, and
        (in Level 3) packages used in addition to SBML Level 3 Core.  A common
        approach to using libSBML's SBMLNamespaces facilities is to create an
        SBMLNamespaces object somewhere in a program once, then hand that
        object as needed to object constructors that accept SBMLNamespaces as
        arguments.

        Parameter 'sbmlns' is an SBMLNamespaces object.

        Throws SBMLConstructorException: Thrown if the given 'sbmlns' is
        inconsistent or incompatible with this object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            Delay(long level, long version)

        Creates a new Delay using the given SBML 'level' and 'version' values.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        Delay.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this Delay.

        Throws SBMLConstructorException: Thrown if the given 'level' and
        'version' combination are invalid or if this object is incompatible
        with the given level and version.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            Delay(Delay orig)

        Copy constructor; creates a copy of this Delay.

        Parameter 'orig' is the object to copy.

        """
        this = _libsbml.new_Delay(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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


        Creates and returns a deep copy of this Delay object.

        Returns the (deep) copy of this Delay object.

        """
        return _libsbml.Delay_clone(self)


    def getMath(self):
        """
        getMath(Delay self) -> ASTNode


        Get the mathematical formula for the delay and return it as an AST.

        Returns the math of this Delay, or 'None' if the math is not set.

        """
        return _libsbml.Delay_getMath(self)


    def isSetMath(self):
        """
        isSetMath(Delay self) -> bool


        Predicate to test whether the formula for this delay is set.

        Returns 'True' if the formula (meaning the 'math' subelement) of this
        Delay is set, 'False' otherwise.

        """
        return _libsbml.Delay_isSetMath(self)


    def setMath(self, math):
        """
        setMath(Delay self, ASTNode math) -> int


        Sets the delay expression of this Delay instance to a copy of the
        given ASTNode.

        Parameter 'math' is an ASTNode representing a formula tree.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_OBJECT

        """
        return _libsbml.Delay_setMath(self, math)


    def getDerivedUnitDefinition(self, *args):
        """
        getDerivedUnitDefinition(Delay self) -> UnitDefinition
        getDerivedUnitDefinition(Delay self) -> UnitDefinition


        Calculates and returns a UnitDefinition that expresses the units of
        measurement assumed for the 'math' expression of this Delay.

        Delay elements in SBML express a time delay for an Event.  Beginning
        with SBML Level 2 Version 2, the units of that time are calculated
        based on the mathematical expression and the model quantities
        referenced by <ci> elements used within that expression.  (In SBML
        Level 2 Version 1, there exists an attribute on Event called
        'timeUnits'.  This attribute can be used to set the units of the Delay
        expression explicitly.)  The method Delay.getDerivedUnitDefinition()
        returns what libSBML computes the units to be, to the extent that
        libSBML can compute them.

        Note: The functionality that facilitates unit analysis depends on the
        model as a whole.  Thus, in cases where the object has not been added
        to a model or the model itself is incomplete, unit analysis is not
        possible and this method will return 'None.'

        WARNING:

        Note that it is possible the 'math' expression in the Delay contains
        literal numbers or parameters with undeclared units.  In those cases,
        it is not possible to calculate the units of the overall expression
        without making assumptions.  LibSBML does not make assumptions about
        the units, and Delay.getDerivedUnitDefinition() only returns the units
        as far as it is able to determine them.  For example, in an expression
        X + Y, if X has unambiguously-defined units and Y does not, it will
        return the units of X.  When using this method, it is critical that
        callers also invoke the method Delay.containsUndeclaredUnits() to
        determine whether this situation holds.  Callers should take suitable
        action in those situations.

        Returns a UnitDefinition that expresses the units of the math
        expression of this Delay, or 'None' if one cannot be constructed.

        See also containsUndeclaredUnits().

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


    def containsUndeclaredUnits(self, *args):
        """
        containsUndeclaredUnits(Delay self) -> bool
        containsUndeclaredUnits(Delay self) -> bool


        Predicate returning 'True' if the 'math' expression in this Delay
        instance contains parameters with undeclared units or literal numbers.

        Delay elements in SBML express a time delay for an Event.  Beginning
        with SBML Level 2 Version 2, the units of that time are calculated
        based on the mathematical expression and the model quantities
        referenced by <ci> elements used within that expression.  (In SBML
        Level 2 Version 1, there exists an attribute on Event called
        'timeUnits'.  This attribute can be used to set the units of the Delay
        expression explicitly.)  The method Delay.getDerivedUnitDefinition()
        returns what libSBML computes the units to be, to the extent that
        libSBML can compute them.

        If the expression contains literal numbers or parameters with
        undeclared units, libSBML may not be able to compute the full units of
        the expression and will only return what it can compute.  Callers
        should always use Delay.containsUndeclaredUnits() when using
        Delay.getDerivedUnitDefinition() to decide whether the returned units
        may be incomplete.

        Returns 'True' if the math expression of this Delay includes
        numbers/parameters with undeclared units, 'False' otherwise.

        Note: A return value of 'True' indicates that the UnitDefinition
        returned by Delay.getDerivedUnitDefinition() may not accurately
        represent the units of the expression.

        See also getDerivedUnitDefinition().

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


    def getTypeCode(self):
        """
        getTypeCode(Delay self) -> int


        Returns the libSBML type code of this object instance.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_DELAY (default).

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.Delay_getTypeCode(self)


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


        Returns the XML element name of this object, which for Delay, is
        always ''delay'.'

        Returns the name of this element, i.e., ''delay'.'

        See also getTypeCode().

        """
        return _libsbml.Delay_getElementName(self)


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


        Predicate returning 'True' if all the required elements for this Delay
        object have been set.

        Note: The required elements for a Delay object are:

        * 'math' inSBML Level 2 and Level 3 Version 1.   (In SBML Level 3
        Version 2+, it is no longer required.)

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

        """
        return _libsbml.Delay_hasRequiredElements(self)


    def removeFromParentAndDelete(self):
        """
        removeFromParentAndDelete(Delay self) -> int


        Finds this Delay's Event parent and calls unsetDelay() on it,
        indirectly deleting itself.

        Overridden from the SBase function since the parent is not a ListOf.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Delay_removeFromParentAndDelete(self)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(Delay self, string oldid, string newid)


        Replaces all uses of a given 'SIdRef' type attribute value with
        another value.

        In SBML, object identifiers are of a data type called SId. In SBML
        Level 3, an explicit data type called SIdRef was introduced for
        attribute values that refer to SId values; in previous Levels of SBML,
        this data type did not exist and attributes were simply described to
        as 'referring to an identifier', but the effective data type was the
        same as SIdRef in Level 3.  These and other methods of libSBML refer
        to the type SIdRef for all Levels of SBML, even if the corresponding
        SBML specification did not explicitly name the data type.

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas in MathML content, comparing the referenced
        identifiers to the value of 'oldid'.  If any matches are found, the
        matching values are replaced with 'newid'.  The method does not
        descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.Delay_renameSIdRefs(self, oldid, newid)


    def renameUnitSIdRefs(self, oldid, newid):
        """
        renameUnitSIdRefs(Delay self, string oldid, string newid)


        Replaces all uses of a given 'UnitSIdRef' type attribute value with
        another value.

        In SBML, unit definitions have identifiers of type UnitSId.  In SBML
        Level 3, an explicit data type called UnitSIdRef was introduced for
        attribute values that refer to UnitSId values; in previous Levels of
        SBML, this data type did not exist and attributes were simply
        described to as 'referring to a unit identifier', but the effective
        data type was the same as UnitSIdRef in Level 3.  These and other
        methods of libSBML refer to the type UnitSIdRef for all Levels of
        SBML, even if the corresponding SBML specification did not explicitly
        name the data type.

        This method works by looking at all unit identifier attribute values
        (including, if appropriate, inside mathematical formulas), comparing
        the referenced unit identifiers to the value of 'oldid'.  If any
        matches are found, the matching values are replaced with 'newid'.  The
        method does not descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.Delay_renameUnitSIdRefs(self, oldid, newid)


    def replaceSIDWithFunction(self, id, function):
        """
        replaceSIDWithFunction(Delay self, string id, ASTNode function)


        Internal implementation method.

        """
        return _libsbml.Delay_replaceSIDWithFunction(self, id, function)

Delay_swigregister = _libsbml.Delay_swigregister
Delay_swigregister(Delay)

class Priority(SBase):
    """

    The priority of execution of an SBML event.

    The Priority object class (which was introduced in SBML Level 3
    Version 1), like Delay, is derived from SBase and contains a MathML
    formula stored in the element 'math'.  This formula is used to compute
    a dimensionless numerical value that influences the order in which a
    simulator is to perform the assignments of two or more events that
    happen to be executed simultaneously.  The formula may evaluate to any
    'float' value (and thus may be a positive or negative number, or
    zero), with positive numbers taken to signifying a higher priority
    than zero or negative numbers.  If no Priority object is present on a
    given Event object, no priority is defined for that event.

    The interpretation of priorities on events in a model
    ======================================================================

    For the purposes of SBML, simultaneous event execution is defined as
    the situation in which multiple events have identical times of
    execution.  The time of execution is calculated as the sum of the time
    at which a given event's Trigger is triggered plus its Delay duration,
    if any.  Here, identical times means mathematically equal instants in
    time.  (In practice, simulation software adhering to this
    specification may have to rely on numerical equality instead of strict
    mathematical equality; robust models will ensure that this difference
    will not cause significant discrepancies from expected behavior.)

    If no Priority subobjects are defined for two or more Event objects,
    then those events are still executed simultaneously but their order of
    execution is undefined by the SBML Level 3 specification.  A software
    implementation may choose to execute such simultaneous events in any
    order, as long as each event is executed only once and the
    requirements of checking the 'persistent' attribute (and acting
    accordingly) are satisfied.

    If Priority subobjects are defined for two or more simultaneously-
    triggered events, the order in which those particular events must be
    executed is dictated by their Priority objects, as follows.  If the
    values calculated using the two Priority objects' 'math' expressions
    differ, then the event having the higher priority value must be
    executed before the event with the lower value.  If, instead, the two
    priority values are mathematically equal, then the two events must be
    triggered in a random order.  It is important to note that a random
    order is not the same as an undefined order: given multiple runs of
    the same model with identical conditions, an undefined ordering would
    permit a system to execute the events in (for example) the same order
    every time (according to whatever scheme may have been implemented by
    the system), whereas the explicit requirement for random ordering
    means that the order of execution in different simulation runs depends
    on random chance.  In other words, given two events A and B, a
    randomly-determined order must lead to an equal chance of executing A
    first or B first, every time those two events are executed
    simultaneously.

    A model may contain a mixture of events, some of which have Priority
    subobjects and some do not.  Should a combination of simultaneous
    events arise in which some events have priorities defined and others
    do not, the set of events with defined priorities must trigger in the
    order determined by their Priority objects, and the set of events
    without Priority objects must be executed in an undefined order with
    respect to each other and with respect to the events with Priority
    subobjects.  (Note that undefined order does not necessarily mean
    random order, although a random ordering would be a valid
    implementation of this requirement.)

    The following example may help further clarify these points. Suppose a
    model contains four events that should be executed simultaneously,
    with two of the events having Priority objects with the same value and
    the other two events having Priority objects with the same, but
    different, value.  The two events with the higher priorities must be
    executed first, in a random order with respect to each other, and the
    remaining two events must be executed after them, again in a random
    order, for a total of four possible and equally-likely event
    executions: A-B-C-D, A-B-D-C, B-A-C-D, and B-A-D-C.  If, instead, the
    model contains four events all having the same Priority values, there
    are 4! or 24 possible orderings, each of which must be equally likely
    to be chosen.  Finally, if none of the four events has a Priority
    subobject defined, or even if exactly one of the four events has a
    defined Priority, there are again 24 possible orderings, but the
    likelihood of choosing any particular ordering is undefined; the
    simulator can choose between events as it wishes.  (The SBML
    specification only defines the effects of priorities on Event objects
    with respect to other Event objects with priorities.  Putting a
    priority on a single Event object in a model does not cause it to fall
    within that scope.)

    Evaluation of Priority expressions
    ======================================================================

    An event's Priority object 'math' expression must be evaluated at the
    time the Event is to be executed.  During a simulation, all
    simultaneous events have their Priority values calculated, and the
    event with the highest priority is selected for next execution.  Note
    that it is possible for the execution of one Event object to cause the
    Priority value of another simultaneously-executing Event object to
    change (as well as to trigger other events, as already noted).  Thus,
    after executing one event, and checking whether any other events in
    the model have been triggered, all remaining simultaneous events that
    either (i) have Trigger objects with attributes 'persistent'='False'
    or (ii) have Trigger expressions that did not transition from 'True'
    to 'False,' must have their Priority expression reevaluated. The
    highest-priority remaining event must then be selected for  execution
    next.

    Units of Priority object's mathematical expressions
    ======================================================================

    The unit associated with the value of a Priority object's 'math'
    expression should be 'dimensionless.'  This is because the priority
    expression only serves to provide a relative ordering between
    different events, and only has meaning with respect to other Priority
    object expressions.  The value of Priority objects is not comparable
    to any other kind of object in an SBML model.

    Note: The Priority construct exists only in SBML Level 3; it cannot be
    used in SBML Level 2 or Level 1 models.

    Restrictions relaxed in SBML Level 3 Version 2
    ======================================================================

    In SBML Level 3 Version 2, the requirement that a Priority have a
    'math' subelement was relaxed, making it optional.  In this case, the
    Priority remains undefined, and unless that information is provided in
    some other form (such as with an SBML Level 3 package), the Event
    behaves as if it had no Priority.

    See also Event, Delay, EventAssignment.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Priority, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Priority, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_Priority
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(Priority self, unsigned int level, unsigned int version) -> Priority
        __init__(Priority self, SBMLNamespaces sbmlns) -> Priority
        __init__(Priority self, Priority orig) -> Priority


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            Priority(SBMLNamespaces sbmlns)

        Creates a new Priority object using the given SBMLNamespaces object
        'sbmlns'.

        The SBMLNamespaces object encapsulates SBML Level/Version/namespaces
        information.  It is used to communicate the SBML Level, Version, and
        (in Level 3) packages used in addition to SBML Level 3 Core.  A common
        approach to using libSBML's SBMLNamespaces facilities is to create an
        SBMLNamespaces object somewhere in a program once, then hand that
        object as needed to object constructors that accept SBMLNamespaces as
        arguments.

        Parameter 'sbmlns' is an SBMLNamespaces object.

        Throws SBMLConstructorException: Thrown if the given 'sbmlns' is
        inconsistent or incompatible with this object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        Note: The Priority construct exists only in SBML Level 3; it cannot be
        used in SBML Level 2 or Level 1 models.

        ______________________________________________________________________
        Method variant with the following signature:

            Priority(long level, long version)

        Creates a new Priority object using the given SBML 'level' and
        'version' values.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        Priority.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this Priority.

        Throws SBMLConstructorException: Thrown if the given 'level' and
        'version' combination are invalid or if this object is incompatible
        with the given level and version.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        Note: The Priority construct exists only in SBML Level 3; it cannot be
        used in SBML Level 2 or Level 1 models.

        ______________________________________________________________________
        Method variant with the following signature:

            Priority(Priority orig)

        Copy constructor; creates a copy of this Priority.

        Parameter 'orig' is the object to copy.

        """
        this = _libsbml.new_Priority(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(Priority self) -> Priority


        Creates and returns a deep copy of this Priority object.

        Returns the (deep) copy of this Priority object.

        """
        return _libsbml.Priority_clone(self)


    def getMath(self):
        """
        getMath(Priority self) -> ASTNode


        Get the mathematical formula for the priority and return it as an AST.

        Returns the math of this Priority, or 'None' if the math is not set.

        """
        return _libsbml.Priority_getMath(self)


    def isSetMath(self):
        """
        isSetMath(Priority self) -> bool


        Predicate to test whether the formula for this delay is set.

        Returns 'True' if the formula (meaning the 'math' subelement) of this
        Priority is set, 'False' otherwise.

        """
        return _libsbml.Priority_isSetMath(self)


    def setMath(self, math):
        """
        setMath(Priority self, ASTNode math) -> int


        Sets the math expression of this Priority instance to a copy of the
        given ASTNode.

        Parameter 'math' is an ASTNode representing a formula tree.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_OBJECT

        """
        return _libsbml.Priority_setMath(self, math)


    def getTypeCode(self):
        """
        getTypeCode(Priority self) -> int


        Returns the libSBML type code of this object instance.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_PRIORITY (default).
        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.Priority_getTypeCode(self)


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


        Returns the XML element name of this object, which for Priority, is
        always ''priority'.'

        Returns the name of this element, i.e., ''priority'.'

        See also getTypeCode().

        """
        return _libsbml.Priority_getElementName(self)


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


        Predicate returning 'True' if all the required elements for this
        Priority object have been set.

        Note: The required elements for a Priority object are:

        * 'math' inSBML Level 2 and Level 3 Version 1.   (In SBML Level 3
        Version 2+, it is no longer required.)

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

        """
        return _libsbml.Priority_hasRequiredElements(self)


    def removeFromParentAndDelete(self):
        """
        removeFromParentAndDelete(Priority self) -> int


        Finds this Priority's Event parent and calls unsetPriority() on it,
        indirectly deleting itself.

        Overridden from the SBase function since the parent is not a ListOf.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Priority_removeFromParentAndDelete(self)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(Priority self, string oldid, string newid)


        Replaces all uses of a given 'SIdRef' type attribute value with
        another value.

        In SBML, object identifiers are of a data type called SId. In SBML
        Level 3, an explicit data type called SIdRef was introduced for
        attribute values that refer to SId values; in previous Levels of SBML,
        this data type did not exist and attributes were simply described to
        as 'referring to an identifier', but the effective data type was the
        same as SIdRef in Level 3.  These and other methods of libSBML refer
        to the type SIdRef for all Levels of SBML, even if the corresponding
        SBML specification did not explicitly name the data type.

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas in MathML content, comparing the referenced
        identifiers to the value of 'oldid'.  If any matches are found, the
        matching values are replaced with 'newid'.  The method does not
        descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.Priority_renameSIdRefs(self, oldid, newid)


    def renameUnitSIdRefs(self, oldid, newid):
        """
        renameUnitSIdRefs(Priority self, string oldid, string newid)


        Replaces all uses of a given 'UnitSIdRef' type attribute value with
        another value.

        In SBML, unit definitions have identifiers of type UnitSId.  In SBML
        Level 3, an explicit data type called UnitSIdRef was introduced for
        attribute values that refer to UnitSId values; in previous Levels of
        SBML, this data type did not exist and attributes were simply
        described to as 'referring to a unit identifier', but the effective
        data type was the same as UnitSIdRef in Level 3.  These and other
        methods of libSBML refer to the type UnitSIdRef for all Levels of
        SBML, even if the corresponding SBML specification did not explicitly
        name the data type.

        This method works by looking at all unit identifier attribute values
        (including, if appropriate, inside mathematical formulas), comparing
        the referenced unit identifiers to the value of 'oldid'.  If any
        matches are found, the matching values are replaced with 'newid'.  The
        method does not descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.Priority_renameUnitSIdRefs(self, oldid, newid)


    def replaceSIDWithFunction(self, id, function):
        """
        replaceSIDWithFunction(Priority self, string id, ASTNode function)


        Internal implementation method.

        """
        return _libsbml.Priority_replaceSIDWithFunction(self, id, function)

Priority_swigregister = _libsbml.Priority_swigregister
Priority_swigregister(Priority)

class SBO(_object):
    """

    Facilities for using the Systems Biology Ontology.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    The values of 'id' attributes on SBML components allow the components
    to be cross-referenced within a model. The values of 'name' attributes
    on SBML components provide the opportunity to assign them meaningful
    labels suitable for display to humans.  The specific identifiers and
    labels used in a model necessarily must be unrestricted by SBML, so
    that software and users are free to pick whatever they need.  However,
    this freedom makes it more difficult for software tools to determine,
    without additional human intervention, the semantics of models more
    precisely than the semantics provided by the SBML object classes
    defined in other sections of this document.  For example, there is
    nothing inherent in a parameter with identifier k that would indicate
    to a software tool it is a first-order rate constant (if that's what k
    happened to be in some given model).  However, one may need to convert
    a model between different representations (e.g., Henri-Michaelis-
    Menten versus elementary steps), or to use it with different modeling
    approaches (discrete or continuous).  One may also need to relate the
    model components with other description formats such as SBGN
    (http://www.sbgn.org/) using deeper semantics.  Although an advanced
    software tool might be able to deduce the semantics of some model
    components through detailed analysis of the kinetic rate expressions
    and other parts of the model, this quickly becomes infeasible for any
    but the simplest of models.

    An approach to solving this problem is to associate model components
    with terms from carefully curated controlled vocabularies (CVs).  This
    is the purpose of the optional 'sboTerm' attribute provided on the
    SBML class SBase.  The 'sboTerm' attribute always refers to terms
    belonging to the Systems Biology Ontology (SBO).

    Use of SBO
    ======================================================================

    Labeling model components with terms from shared controlled
    vocabularies allows a software tool to identify each component using
    identifiers that are not tool-specific.  An example of where this is
    useful is the desire by many software developers to provide users with
    meaningful names for reaction rate equations.  Software tools with
    editing interfaces frequently provide these names in menus or lists of
    choices for users. However, without a standardized set of names or
    identifiers shared between developers, a given software package cannot
    reliably interpret the names or identifiers of reactions used in
    models written by other tools.

    The first solution that might come to mind is to stipulate that
    certain common reactions always have the same name (e.g., 'Michaelis-
    Menten'), but this is simply impossible to do: not only do humans
    often disagree on the names themselves, but it would not allow for
    correction of errors or updates to the list of predefined names except
    by issuing new releases of the SBML specification---to say nothing of
    many other limitations with this approach.  Moreover, the parameters
    and variables that appear in rate expressions also need to be
    identified in a way that software tools can interpret mechanically,
    implying that the names of these entities would also need to be
    regulated.

    The Systems Biology Ontology (SBO) provides terms for identifying most
    elements of SBML. The relationship implied by an 'sboTerm' on an SBML
    model component is is-a between the characteristic of the component
    meant to be described by SBO on this element and the SBO term
    identified by the value of the 'sboTerm'. By adding SBO term
    references on the components of a model, a software tool can provide
    additional details using independent, shared vocabularies that can
    enable other software tools to recognize precisely what the component
    is meant to be.  Those tools can then act on that information. For
    example, if the SBO identifier ''SBO:0000049'' is assigned to the
    concept of 'first-order irreversible mass-action kinetics, continuous
    framework', and a given KineticLaw object in a model has an 'sboTerm'
    attribute with this value, then regardless of the identifier and name
    given to the reaction itself, a software tool could use this to inform
    users that the reaction is a first-order irreversible mass-action
    reaction.  This kind of reverse engineering of the meaning of
    reactions in a model would be difficult to do otherwise, especially
    for more complex reaction types.

    The presence of SBO labels on Compartment, Species, and Reaction
    objects in SBML can help map those entities to equivalent concepts in
    other standards, such as (but not limited to) BioPAX
    (http://www.biopax.org/), PSI-MI (http://www.psidev.info), or the
    Systems Biology Graphical Notation (SBGN, http://www.sbgn.org/).  Such
    mappings can be used in conversion procedures, or to build interfaces,
    with SBO becoming a kind of 'glue' between standards of
    representation.

    The presence of the label on a kinetic expression can also allow
    software tools to make more intelligent decisions about reaction rate
    expressions.  For example, an application could recognize certain
    types of reaction formulas as being ones it knows how to solve with
    optimized procedures.  The application could then use internal,
    optimized code implementing the rate formula indexed by identifiers
    such as ''SBO:0000049'' appearing in SBML models.

    Finally, SBO labels may be very valuable when it comes to model
    integration, by helping identify interfaces, convert mathematical
    expressions and parameters etc.

    Although the use of SBO can be beneficial, it is critical to keep in
    mind that the presence of an 'sboTerm' value on an object must not
    change the fundamental mathematical meaning of the model.  An SBML
    model must be defined such that it stands on its own and does not
    depend on additional information added by SBO terms for a correct
    mathematical interpretation.  SBO term definitions will not imply any
    alternative mathematical semantics for any SBML object labeled with
    that term.  Two important reasons motivate this principle.  First, it
    would be too limiting to require all software tools to be able to
    understand the SBO vocabularies in addition to understanding SBML.
    Supporting SBO is not only additional work for the software developer;
    for some kinds of applications, it may not make sense.  If SBO terms
    on a model are optional, it follows that the SBML model must remain
    unambiguous and fully interpretable without them, because an
    application reading the model may ignore the terms.  Second, we
    believe allowing the use of 'sboTerm' to alter the mathematical
    meaning of a model would allow too much leeway to shoehorn
    inconsistent concepts into SBML objects, ultimately reducing the
    interoperability of the models.

    Relationships between SBO and SBML
    ======================================================================

    The goal of SBO labeling for SBML is to clarify to the fullest extent
    possible the nature of each element in a model.  The approach taken in
    SBO begins with a hierarchically-structured set of controlled
    vocabularies with six main divisions: (1) entity, (2) participant
    role, (3) quantitative parameter, (4) modeling framework, (5)
    mathematical expression, and (6) interaction.  The web site for SBO
    (http://biomodels.net) should be consulted for the current version of
    the ontology.

    The Systems Biology Ontology (SBO) is not part of SBML; it is being
    developed separately, to allow the modeling community to evolve the
    ontology independently of SBML.  However, the terms in the ontology
    are being designed keeping SBML components in mind, and are classified
    into subsets that can be directly related with SBML components such as
    reaction rate expressions, parameters, and others.  The use of
    'sboTerm' attributes is optional, and the presence of 'sboTerm' on an
    element does not change the way the model is interpreted.  Annotating
    SBML elements with SBO terms adds additional semantic information that
    may be used to convert the model into another model, or another
    format.  Although SBO support provides an important source of
    information to understand the meaning of a model, software does not
    need to support 'sboTerm' to be considered SBML-compliant.

    """

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SBO, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SBO, name)
    __repr__ = _swig_repr

    def isQuantitativeParameter(term):
        """
        isQuantitativeParameter(unsigned int term) -> bool


        Returns 'True' if the given term identifier comes from the stated
        branch of SBO.

        Note: The 'quantitative parameter' SBO term is now known as 'systems
        description parameter'.

        Returns 'True' if 'term' is-a SBO 'quantiative parameter', 'False'
        otherwise.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.SBO_isQuantitativeParameter(term)

    isQuantitativeParameter = staticmethod(isQuantitativeParameter)

    def isParticipantRole(term):
        """
        isParticipantRole(unsigned int term) -> bool


        Returns 'True' if the given term identifier comes from the stated
        branch of SBO.

        Returns 'True' if 'term' is-a SBO 'participant role', 'False'
        otherwise.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.SBO_isParticipantRole(term)

    isParticipantRole = staticmethod(isParticipantRole)

    def isModellingFramework(term):
        """
        isModellingFramework(unsigned int term) -> bool


        Returns 'True' if the given term identifier comes from the stated
        branch of SBO.

        Returns 'True' if 'term' is-a SBO 'modeling framework', 'False'
        otherwise.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.SBO_isModellingFramework(term)

    isModellingFramework = staticmethod(isModellingFramework)

    def isMathematicalExpression(term):
        """
        isMathematicalExpression(unsigned int term) -> bool


        Returns 'True' if the given term identifier comes from the stated
        branch of SBO.

        Returns 'True' if 'term' is-a SBO 'mathematical expression', 'False'
        otherwise.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.SBO_isMathematicalExpression(term)

    isMathematicalExpression = staticmethod(isMathematicalExpression)

    def isKineticConstant(term):
        """
        isKineticConstant(unsigned int term) -> bool


        Returns 'True' if the given term identifier comes from the stated
        branch of SBO.

        Returns 'True' if 'term' is-a SBO 'kinetic constant', 'False'
        otherwise.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.SBO_isKineticConstant(term)

    isKineticConstant = staticmethod(isKineticConstant)

    def isReactant(term):
        """
        isReactant(unsigned int term) -> bool


        Returns 'True' if the given term identifier comes from the stated
        branch of SBO.

        Returns 'True' if 'term' is-a SBO 'reactant', 'False' otherwise.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.SBO_isReactant(term)

    isReactant = staticmethod(isReactant)

    def isProduct(term):
        """
        isProduct(unsigned int term) -> bool


        Returns 'True' if the given term identifier comes from the stated
        branch of SBO.

        Returns 'True' if 'term' is-a SBO 'product', 'False' otherwise.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.SBO_isProduct(term)

    isProduct = staticmethod(isProduct)

    def isModifier(term):
        """
        isModifier(unsigned int term) -> bool


        Returns 'True' if the given term identifier comes from the stated
        branch of SBO.

        Returns 'True' if 'term' is-a SBO 'modifier', 'False' otherwise.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.SBO_isModifier(term)

    isModifier = staticmethod(isModifier)

    def isRateLaw(term):
        """
        isRateLaw(unsigned int term) -> bool


        Returns 'True' if the given term identifier comes from the stated
        branch of SBO.

        Returns 'True' if 'term' is-a SBO 'rate law', 'False' otherwise.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.SBO_isRateLaw(term)

    isRateLaw = staticmethod(isRateLaw)

    def isEvent(term):
        """
        isEvent(unsigned int term) -> bool


        Returns 'True' if the given term identifier comes from the stated
        branch of SBO.

        Returns 'True' if 'term' is-a SBO 'event', 'False' otherwise.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.SBO_isEvent(term)

    isEvent = staticmethod(isEvent)

    def isPhysicalParticipant(term):
        """
        isPhysicalParticipant(unsigned int term) -> bool


        Returns 'True' if the given term identifier comes from the stated
        branch of SBO.

        Returns 'True' if 'term' is-a SBO 'physical participant, 'False'
        otherwise.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.SBO_isPhysicalParticipant(term)

    isPhysicalParticipant = staticmethod(isPhysicalParticipant)

    def isParticipant(term):
        """
        isParticipant(unsigned int term) -> bool


        Returns 'True' if the given term identifier comes from the stated
        branch of SBO.

        Returns 'True' if 'term' is-a SBO 'participant', 'False' otherwise.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.SBO_isParticipant(term)

    isParticipant = staticmethod(isParticipant)

    def isInteraction(term):
        """
        isInteraction(unsigned int term) -> bool


        Returns 'True' if the given term identifier comes from the stated
        branch of SBO.

        Note: The 'interaction' SBO term is now known as 'occurring entity
        representation'.

        Returns 'True' if 'term' is-a SBO 'interaction', 'False' otherwise.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.SBO_isInteraction(term)

    isInteraction = staticmethod(isInteraction)

    def isEntity(term):
        """
        isEntity(unsigned int term) -> bool


        Returns 'True' if the given term identifier comes from the stated
        branch of SBO.

        Note: The 'entity' SBO term is now known as 'physical entity
        representation'.

        Returns 'True' if 'term' is-a SBO 'entity', 'False' otherwise.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.SBO_isEntity(term)

    isEntity = staticmethod(isEntity)

    def isFunctionalEntity(term):
        """
        isFunctionalEntity(unsigned int term) -> bool


        Returns 'True' if the given term identifier comes from the stated
        branch of SBO.

        Returns 'True' if 'term' is-a SBO 'functional entity', 'False'
        otherwise.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.SBO_isFunctionalEntity(term)

    isFunctionalEntity = staticmethod(isFunctionalEntity)

    def isMaterialEntity(term):
        """
        isMaterialEntity(unsigned int term) -> bool


        Returns 'True' if the given term identifier comes from the stated
        branch of SBO.

        Returns 'True' if 'term' is-a SBO 'material entity', 'False'
        otherwise.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.SBO_isMaterialEntity(term)

    isMaterialEntity = staticmethod(isMaterialEntity)

    def isConservationLaw(term):
        """
        isConservationLaw(unsigned int term) -> bool


        Returns 'True' if the given term identifier comes from the stated
        branch of SBO.

        Returns 'True' if 'term' is-a SBO 'conservation law', 'False'
        otherwise.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.SBO_isConservationLaw(term)

    isConservationLaw = staticmethod(isConservationLaw)

    def isSteadyStateExpression(term):
        """
        isSteadyStateExpression(unsigned int term) -> bool


        Returns 'True' if the given term identifier comes from the stated
        branch of SBO.

        Returns 'True' if 'term' is-a SBO 'steady state expression', 'False'
        otherwise.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.SBO_isSteadyStateExpression(term)

    isSteadyStateExpression = staticmethod(isSteadyStateExpression)

    def isFunctionalCompartment(term):
        """
        isFunctionalCompartment(unsigned int term) -> bool


        Returns 'True' if the given term identifier comes from the stated
        branch of SBO.

        Returns 'True' if 'term' is-a SBO 'functional compartment', 'False'
        otherwise.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.SBO_isFunctionalCompartment(term)

    isFunctionalCompartment = staticmethod(isFunctionalCompartment)

    def isContinuousFramework(term):
        """
        isContinuousFramework(unsigned int term) -> bool


        Returns 'True' if the given term identifier comes from the stated
        branch of SBO.

        Returns 'True' if 'term' is-a SBO 'continuous framework', 'False'
        otherwise.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.SBO_isContinuousFramework(term)

    isContinuousFramework = staticmethod(isContinuousFramework)

    def isDiscreteFramework(term):
        """
        isDiscreteFramework(unsigned int term) -> bool


        Returns 'True' if the given term identifier comes from the stated
        branch of SBO.

        Returns 'True' if 'term' is-a SBO 'discrete framework', 'False'
        otherwise.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.SBO_isDiscreteFramework(term)

    isDiscreteFramework = staticmethod(isDiscreteFramework)

    def isLogicalFramework(term):
        """
        isLogicalFramework(unsigned int term) -> bool


        Returns 'True' if the given term identifier comes from the stated
        branch of SBO.

        Returns 'True' if 'term' is-a SBO 'logical framework', 'False'
        otherwise.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.SBO_isLogicalFramework(term)

    isLogicalFramework = staticmethod(isLogicalFramework)

    def isMetadataRepresentation(term):
        """
        isMetadataRepresentation(unsigned int term) -> bool


        Returns 'True' if the given term identifier comes from the stated
        branch of SBO.

        Returns 'True' if 'term' is-a SBO 'metadata representation', 'False'
        otherwise.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.SBO_isMetadataRepresentation(term)

    isMetadataRepresentation = staticmethod(isMetadataRepresentation)

    def isOccurringEntityRepresentation(term):
        """
        isOccurringEntityRepresentation(unsigned int term) -> bool


        Returns 'True' if the given term identifier comes from the stated
        branch of SBO.

        Returns 'True' if 'term' is-a SBO 'occurring entity representation',
        'False' otherwise.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.SBO_isOccurringEntityRepresentation(term)

    isOccurringEntityRepresentation = staticmethod(isOccurringEntityRepresentation)

    def isPhysicalEntityRepresentation(term):
        """
        isPhysicalEntityRepresentation(unsigned int term) -> bool


        Returns 'True' if the given term identifier comes from the stated
        branch of SBO.

        Returns 'True' if 'term' is-a SBO 'physical entity representation',
        'False' otherwise.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.SBO_isPhysicalEntityRepresentation(term)

    isPhysicalEntityRepresentation = staticmethod(isPhysicalEntityRepresentation)

    def isSystemsDescriptionParameter(term):
        """
        isSystemsDescriptionParameter(unsigned int term) -> bool


        Returns 'True' if the given term identifier comes from the stated
        branch of SBO.

        Returns 'True' if 'term' is-a SBO 'systems description parameter',
        'False' otherwise.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.SBO_isSystemsDescriptionParameter(term)

    isSystemsDescriptionParameter = staticmethod(isSystemsDescriptionParameter)

    def isQuantitativeSystemsDescriptionParameter(term):
        """
        isQuantitativeSystemsDescriptionParameter(unsigned int term) -> bool


        Returns 'True' if the given term identifier comes from the stated
        branch of SBO.

        Returns 'True' if 'term' is-a SBO 'quantiative systems description
        parameter', 'False' otherwise.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.SBO_isQuantitativeSystemsDescriptionParameter(term)

    isQuantitativeSystemsDescriptionParameter = staticmethod(isQuantitativeSystemsDescriptionParameter)

    def isObselete(term):
        """
        isObselete(unsigned int term) -> bool


        Predicate for checking whether the given term is obsolete.

        Returns 'True' if 'term' is-a SBO 'obsolete' term, 'False' otherwise.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.SBO_isObselete(term)

    isObselete = staticmethod(isObselete)

    def intToString(sboTerm):
        """
        intToString(int sboTerm) -> string


        Returns the integer as a correctly formatted SBO identifier string.

        Returns the given integer sboTerm as a zero-padded seven digit string.

        Note: If the sboTerm is not in the correct range (0000000-9999999), an
        empty string is returned.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.SBO_intToString(sboTerm)

    intToString = staticmethod(intToString)

    def stringToInt(sboTerm):
        """
        stringToInt(string sboTerm) -> int


        Returns the string as a correctly formatted SBO integer portion.

        Returns the given string sboTerm as an integer.  If the sboTerm is not
        in the correct format (a zero-padded, seven digit string), -1 is
        returned.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.SBO_stringToInt(sboTerm)

    stringToInt = staticmethod(stringToInt)

    def checkTerm(*args):
        """
        checkTerm(string sboTerm) -> bool
        checkTerm(int sboTerm) -> bool


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            checkTerm(string sboTerm)

        Checks the format of the given SBO identifier string.

        Returns 'True' if sboTerm is in the correct format (a zero-padded,
        seven digit string), 'False' otherwise.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        ______________________________________________________________________
        Method variant with the following signature:

            checkTerm(int sboTerm)

        Checks the format of the given SBO identifier, given in the form of
        the integer portion alone.

        Returns 'True' if sboTerm is in the range (0000000-9999999), 'False'
        otherwise.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.SBO_checkTerm(*args)

    checkTerm = staticmethod(checkTerm)

    def getParentBranch(term):
        """
        getParentBranch(unsigned int term) -> unsigned int


        Internal implementation method.

        """
        return _libsbml.SBO_getParentBranch(term)

    getParentBranch = staticmethod(getParentBranch)

    def __init__(self):
        """
        __init__(SBO self) -> SBO


        @internal

        """
        this = _libsbml.new_SBO()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_SBO
    __del__ = lambda self: None
SBO_swigregister = _libsbml.SBO_swigregister
SBO_swigregister(SBO)

def SBO_isQuantitativeParameter(term):
    """
    SBO_isQuantitativeParameter(unsigned int term) -> bool


    Returns 'True' if the given term identifier comes from the stated
    branch of SBO.

    Note: The 'quantitative parameter' SBO term is now known as 'systems
    description parameter'.

    Returns 'True' if 'term' is-a SBO 'quantiative parameter', 'False'
    otherwise.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.SBO_isQuantitativeParameter(term)

def SBO_isParticipantRole(term):
    """
    SBO_isParticipantRole(unsigned int term) -> bool


    Returns 'True' if the given term identifier comes from the stated
    branch of SBO.

    Returns 'True' if 'term' is-a SBO 'participant role', 'False'
    otherwise.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.SBO_isParticipantRole(term)

def SBO_isModellingFramework(term):
    """
    SBO_isModellingFramework(unsigned int term) -> bool


    Returns 'True' if the given term identifier comes from the stated
    branch of SBO.

    Returns 'True' if 'term' is-a SBO 'modeling framework', 'False'
    otherwise.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.SBO_isModellingFramework(term)

def SBO_isMathematicalExpression(term):
    """
    SBO_isMathematicalExpression(unsigned int term) -> bool


    Returns 'True' if the given term identifier comes from the stated
    branch of SBO.

    Returns 'True' if 'term' is-a SBO 'mathematical expression', 'False'
    otherwise.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.SBO_isMathematicalExpression(term)

def SBO_isKineticConstant(term):
    """
    SBO_isKineticConstant(unsigned int term) -> bool


    Returns 'True' if the given term identifier comes from the stated
    branch of SBO.

    Returns 'True' if 'term' is-a SBO 'kinetic constant', 'False'
    otherwise.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.SBO_isKineticConstant(term)

def SBO_isReactant(term):
    """
    SBO_isReactant(unsigned int term) -> bool


    Returns 'True' if the given term identifier comes from the stated
    branch of SBO.

    Returns 'True' if 'term' is-a SBO 'reactant', 'False' otherwise.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.SBO_isReactant(term)

def SBO_isProduct(term):
    """
    SBO_isProduct(unsigned int term) -> bool


    Returns 'True' if the given term identifier comes from the stated
    branch of SBO.

    Returns 'True' if 'term' is-a SBO 'product', 'False' otherwise.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.SBO_isProduct(term)

def SBO_isModifier(term):
    """
    SBO_isModifier(unsigned int term) -> bool


    Returns 'True' if the given term identifier comes from the stated
    branch of SBO.

    Returns 'True' if 'term' is-a SBO 'modifier', 'False' otherwise.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.SBO_isModifier(term)

def SBO_isRateLaw(term):
    """
    SBO_isRateLaw(unsigned int term) -> bool


    Returns 'True' if the given term identifier comes from the stated
    branch of SBO.

    Returns 'True' if 'term' is-a SBO 'rate law', 'False' otherwise.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.SBO_isRateLaw(term)

def SBO_isEvent(term):
    """
    SBO_isEvent(unsigned int term) -> bool


    Returns 'True' if the given term identifier comes from the stated
    branch of SBO.

    Returns 'True' if 'term' is-a SBO 'event', 'False' otherwise.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.SBO_isEvent(term)

def SBO_isPhysicalParticipant(term):
    """
    SBO_isPhysicalParticipant(unsigned int term) -> bool


    Returns 'True' if the given term identifier comes from the stated
    branch of SBO.

    Returns 'True' if 'term' is-a SBO 'physical participant, 'False'
    otherwise.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.SBO_isPhysicalParticipant(term)

def SBO_isParticipant(term):
    """
    SBO_isParticipant(unsigned int term) -> bool


    Returns 'True' if the given term identifier comes from the stated
    branch of SBO.

    Returns 'True' if 'term' is-a SBO 'participant', 'False' otherwise.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.SBO_isParticipant(term)

def SBO_isInteraction(term):
    """
    SBO_isInteraction(unsigned int term) -> bool


    Returns 'True' if the given term identifier comes from the stated
    branch of SBO.

    Note: The 'interaction' SBO term is now known as 'occurring entity
    representation'.

    Returns 'True' if 'term' is-a SBO 'interaction', 'False' otherwise.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.SBO_isInteraction(term)

def SBO_isEntity(term):
    """
    SBO_isEntity(unsigned int term) -> bool


    Returns 'True' if the given term identifier comes from the stated
    branch of SBO.

    Note: The 'entity' SBO term is now known as 'physical entity
    representation'.

    Returns 'True' if 'term' is-a SBO 'entity', 'False' otherwise.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.SBO_isEntity(term)

def SBO_isFunctionalEntity(term):
    """
    SBO_isFunctionalEntity(unsigned int term) -> bool


    Returns 'True' if the given term identifier comes from the stated
    branch of SBO.

    Returns 'True' if 'term' is-a SBO 'functional entity', 'False'
    otherwise.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.SBO_isFunctionalEntity(term)

def SBO_isMaterialEntity(term):
    """
    SBO_isMaterialEntity(unsigned int term) -> bool


    Returns 'True' if the given term identifier comes from the stated
    branch of SBO.

    Returns 'True' if 'term' is-a SBO 'material entity', 'False'
    otherwise.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.SBO_isMaterialEntity(term)

def SBO_isConservationLaw(term):
    """
    SBO_isConservationLaw(unsigned int term) -> bool


    Returns 'True' if the given term identifier comes from the stated
    branch of SBO.

    Returns 'True' if 'term' is-a SBO 'conservation law', 'False'
    otherwise.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.SBO_isConservationLaw(term)

def SBO_isSteadyStateExpression(term):
    """
    SBO_isSteadyStateExpression(unsigned int term) -> bool


    Returns 'True' if the given term identifier comes from the stated
    branch of SBO.

    Returns 'True' if 'term' is-a SBO 'steady state expression', 'False'
    otherwise.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.SBO_isSteadyStateExpression(term)

def SBO_isFunctionalCompartment(term):
    """
    SBO_isFunctionalCompartment(unsigned int term) -> bool


    Returns 'True' if the given term identifier comes from the stated
    branch of SBO.

    Returns 'True' if 'term' is-a SBO 'functional compartment', 'False'
    otherwise.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.SBO_isFunctionalCompartment(term)

def SBO_isContinuousFramework(term):
    """
    SBO_isContinuousFramework(unsigned int term) -> bool


    Returns 'True' if the given term identifier comes from the stated
    branch of SBO.

    Returns 'True' if 'term' is-a SBO 'continuous framework', 'False'
    otherwise.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.SBO_isContinuousFramework(term)

def SBO_isDiscreteFramework(term):
    """
    SBO_isDiscreteFramework(unsigned int term) -> bool


    Returns 'True' if the given term identifier comes from the stated
    branch of SBO.

    Returns 'True' if 'term' is-a SBO 'discrete framework', 'False'
    otherwise.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.SBO_isDiscreteFramework(term)

def SBO_isLogicalFramework(term):
    """
    SBO_isLogicalFramework(unsigned int term) -> bool


    Returns 'True' if the given term identifier comes from the stated
    branch of SBO.

    Returns 'True' if 'term' is-a SBO 'logical framework', 'False'
    otherwise.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.SBO_isLogicalFramework(term)

def SBO_isMetadataRepresentation(term):
    """
    SBO_isMetadataRepresentation(unsigned int term) -> bool


    Returns 'True' if the given term identifier comes from the stated
    branch of SBO.

    Returns 'True' if 'term' is-a SBO 'metadata representation', 'False'
    otherwise.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.SBO_isMetadataRepresentation(term)

def SBO_isOccurringEntityRepresentation(term):
    """
    SBO_isOccurringEntityRepresentation(unsigned int term) -> bool


    Returns 'True' if the given term identifier comes from the stated
    branch of SBO.

    Returns 'True' if 'term' is-a SBO 'occurring entity representation',
    'False' otherwise.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.SBO_isOccurringEntityRepresentation(term)

def SBO_isPhysicalEntityRepresentation(term):
    """
    SBO_isPhysicalEntityRepresentation(unsigned int term) -> bool


    Returns 'True' if the given term identifier comes from the stated
    branch of SBO.

    Returns 'True' if 'term' is-a SBO 'physical entity representation',
    'False' otherwise.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.SBO_isPhysicalEntityRepresentation(term)

def SBO_isSystemsDescriptionParameter(term):
    """
    SBO_isSystemsDescriptionParameter(unsigned int term) -> bool


    Returns 'True' if the given term identifier comes from the stated
    branch of SBO.

    Returns 'True' if 'term' is-a SBO 'systems description parameter',
    'False' otherwise.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.SBO_isSystemsDescriptionParameter(term)

def SBO_isQuantitativeSystemsDescriptionParameter(term):
    """
    SBO_isQuantitativeSystemsDescriptionParameter(unsigned int term) -> bool


    Returns 'True' if the given term identifier comes from the stated
    branch of SBO.

    Returns 'True' if 'term' is-a SBO 'quantiative systems description
    parameter', 'False' otherwise.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.SBO_isQuantitativeSystemsDescriptionParameter(term)

def SBO_isObselete(term):
    """
    SBO_isObselete(unsigned int term) -> bool


    Predicate for checking whether the given term is obsolete.

    Returns 'True' if 'term' is-a SBO 'obsolete' term, 'False' otherwise.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.SBO_isObselete(term)

def SBO_intToString(sboTerm):
    """
    SBO_intToString(int sboTerm) -> string


    Returns the integer as a correctly formatted SBO identifier string.

    Returns the given integer sboTerm as a zero-padded seven digit string.

    Note: If the sboTerm is not in the correct range (0000000-9999999), an
    empty string is returned.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.SBO_intToString(sboTerm)

def SBO_stringToInt(sboTerm):
    """
    SBO_stringToInt(string sboTerm) -> int


    Returns the string as a correctly formatted SBO integer portion.

    Returns the given string sboTerm as an integer.  If the sboTerm is not
    in the correct format (a zero-padded, seven digit string), -1 is
    returned.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.SBO_stringToInt(sboTerm)

def SBO_checkTerm(*args):
    """
    checkTerm(string sboTerm) -> bool
    SBO_checkTerm(int sboTerm) -> bool


    This method has multiple variants; they differ in the arguments  they
    accept.  Each variant is described separately below.

    ______________________________________________________________________
    Method variant with the following signature:

        checkTerm(string sboTerm)

    Checks the format of the given SBO identifier string.

    Returns 'True' if sboTerm is in the correct format (a zero-padded,
    seven digit string), 'False' otherwise.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    ______________________________________________________________________
    Method variant with the following signature:

        checkTerm(int sboTerm)

    Checks the format of the given SBO identifier, given in the form of
    the integer portion alone.

    Returns 'True' if sboTerm is in the range (0000000-9999999), 'False'
    otherwise.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.SBO_checkTerm(*args)

def SBO_getParentBranch(term):
    """
    SBO_getParentBranch(unsigned int term) -> unsigned int


    Internal implementation method.

    """
    return _libsbml.SBO_getParentBranch(term)

class SyntaxChecker(_object):
    """

    Methods for checking the validity of SBML identifiers.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    This utility class provides static methods for checking the syntax of
    identifiers and other text used in an SBML model.  The methods allow
    callers to verify that strings such as SBML identifiers and XHTML
    notes text conform to the SBML specifications.

    """

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SyntaxChecker, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SyntaxChecker, name)
    __repr__ = _swig_repr

    def isValidSBMLSId(sid):
        """
        isValidSBMLSId(string sid) -> bool


        Returns 'True' or 'False' depending on whether the argument string
        conforms to the syntax of SBML identifiers.

        In SBML, identifiers that are the values of 'id' attributes on
        objects must conform to a data type called SId in the SBML
        specifications.  LibSBML does not provide an explicit SId data type;
        it uses ordinary character strings, which is easier for applications
        to support.  (LibSBML does, however, test for identifier validity at
        various times, such as when reading in models from files and data
        streams.)

        This method provides programs with the ability to test explicitly that
        the identifier strings they create conform to the SBML identifier
        syntax.

        Parameter 'sid' is string to be checked for conformance to SBML
        identifier syntax.

        Returns 'True' if the string conforms to type SBML data type SId,
        'False' otherwise.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The equality of SId and SId-derived values in SBML is determined by
        an exact character sequence match; i.e., comparisons of these
        identifiers must be performed in a case-sensitive manner.  This
        applies to all uses of SId,  SIdRef, and derived types.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        See also SyntaxChecker.isValidUnitSId() , SyntaxChecker.isValidXMLID()
        .

        """
        return _libsbml.SyntaxChecker_isValidSBMLSId(sid)

    isValidSBMLSId = staticmethod(isValidSBMLSId)

    def isValidXMLID(id):
        """
        isValidXMLID(string id) -> bool


        Returns 'True' or 'False' depending on whether the argument string
        conforms to the XML data type ID.

        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
        XML ID, the XML identifier type, which means each 'metaid' value must
        be globally unique within an SBML file.  The latter point is
        important, because the uniqueness criterion applies across any
        attribute with type ID anywhere in the file, not just the 'metaid'
        attribute used by SBML---something to be aware of if your application-
        specific XML content inside the 'annotation' subelement happens to use
        the XML ID type.  Although SBML itself specifies the use of XML ID
        only for the 'metaid' attribute, SBML-compatible applications should
        be careful if they use XML ID's in XML portions of a model that are
        not defined by SBML, such as in the application-specific content of
        the 'annotation' subelement.  Finally, note that LibSBML does not
        provide an explicit XML ID data type; it uses ordinary character
        strings, which is easier for applications to support.

        This method provides programs with the ability to test explicitly that
        the identifier strings they create conform to the SBML identifier
        syntax.

        Parameter 'id' is string to be checked for conformance to the syntax
        of XML ID.

        Returns 'True' if the string is a syntactically-valid value for the
        XML type ID, 'False' otherwise.

        Note: The following is a summary of the definition of the XML 1.0 data
        type ID.  We express the syntax using an extended form of BNF
        notation: <p> <nobr>NCNameChar ::= letter | digit | '.' | '-' | '_' |
        ':' | CombiningChar | Extender </nobr> ID ::= ( letter | '_' | ':' )
        NCNameChar* <p> The characters ( and ) are used for grouping, the
        character * means "zero or more times", and the character |
        indicates logical "or". The production letter consists of the basic
        upper and lower case alphabetic characters of the Latin alphabet along
        with a large number of related characters defined by Unicode 2.0;
        similarly, the production digit consists of the numerals 0..9 along
        with related Unicode 2.0 characters.  The CombiningChar production is
        a list of characters that add such things as accents to the preceding
        character. (For example, the Unicode character \#x030A when combined
        with a produces a.)  The Extender production is a list of characters
        that extend the shape of the preceding character.  Please consult the
        XML 1.0 specification for the complete definitions of letter, digit,
        CombiningChar, and Extender. <p>

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        See also SyntaxChecker.isValidSBMLSId() ,
        SyntaxChecker.isValidUnitSId() .

        """
        return _libsbml.SyntaxChecker_isValidXMLID(id)

    isValidXMLID = staticmethod(isValidXMLID)

    def isValidXMLanyURI(uri):
        """
        isValidXMLanyURI(string uri) -> bool


        Returns 'True' or 'False' depending on whether the 'uri' argument
        string conforms to the XML data type anyURI.

        Type anyURI is defined by XML Schema 1.0. It is a character string
        data type whose values are interpretable as URIs (Universal Resource
        Identifiers) as described by the W3C document RFC 3986.  LibSBML does
        not provide an explicit XML anyURI data type; it uses ordinary
        character strings, which is easier for applications to support.
        LibSBML does, however, test for anyURI validity at various times, such
        as when reading in models from files and data streams.

        This method provides programs with the ability to test explicitly that
        the strings they create conform to the XML anyURI syntax.

        Parameter 'uri' is string to be checked for conformance to the syntax
        of anyURI.

        Returns 'True' if the string is a syntactically-valid value for the
        XML type anyURI,  'False' otherwise.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.SyntaxChecker_isValidXMLanyURI(uri)

    isValidXMLanyURI = staticmethod(isValidXMLanyURI)

    def isValidUnitSId(units):
        """
        isValidUnitSId(string units) -> bool


        Returns 'True' or 'False' depending on whether the argument string
        conforms to the syntax of SBML unit identifiers.

        In SBML, the identifiers of units (of both the predefined units and
        user-defined units) must conform to a data type called UnitSId in the
        SBML specifications.  LibSBML does not provide an explicit UnitSId
        data type; it uses ordinary character strings, which is easier for
        applications to support. LibSBML does, however, test for identifier
        validity at various times, such as when reading in models from files
        and data streams.

        This method provides programs with the ability to test explicitly that
        the identifier strings they create conform to the SBML identifier
        syntax.

        Parameter 'units' is string to be checked for conformance to SBML unit
        identifier syntax.

        Returns 'True' if the string conforms to type SBML data type UnitSId,
        'False' otherwise.

        Note: The following is a summary of the definition of the SBML
        identifier type UnitSId, which defines the permitted syntax of
        identifiers. We express the syntax using an extended form of BNF
        notation: <p> letter ::= 'a'..'z','A'..'Z' digit  ::= '0'..'9' idChar
        ::= letter | digit | '_' SId    ::= ( letter | '_' ) idChar* <p> The
        characters ( and ) are used for grouping, the character * "zero or
        more times", and the character | indicates logical "or".  The
        equality of SBML unit 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 unit identifiers in an SBML model.  Please consult the
        SBML specifications for the exact formulations. <p>

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        See also SyntaxChecker.isValidSBMLSId() , SyntaxChecker.isValidXMLID()
        .

        """
        return _libsbml.SyntaxChecker_isValidUnitSId(units)

    isValidUnitSId = staticmethod(isValidUnitSId)

    def hasExpectedXHTMLSyntax(xhtml, sbmlns=None):
        """
        hasExpectedXHTMLSyntax(XMLNode xhtml, SBMLNamespaces sbmlns=None) -> bool
        hasExpectedXHTMLSyntax(XMLNode xhtml) -> bool


        Returns 'True' or 'False' depending on whether the given XMLNode
        object contains valid XHTML content.

        The optional SBML element named 'notes', present on every major SBML
        component type (and in SBML Level 3, the 'message' subelement of
        Constraint), 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 conform to the definition of XHTML 1.0.
        However, the content cannot be entirely free-form; it must satisfy
        certain requirements defined in the SBML specifications for specific
        SBML Levels.  To help verify the formatting of 'notes' content,
        libSBML provides the static utility method
        SyntaxChecker.hasExpectedXHTMLSyntax(); this method implements a
        verification process that lets callers check whether the content of a
        given XMLNode object conforms to the SBML requirements for 'notes' and
        'message' structure.  Developers are urged to consult the appropriate
        SBML specification document for the Level and Version of their model
        for more in-depth explanations of using 'notes' in SBML.  The SBML
        Level 2 and 3 specifications have considerable detail about how
        'notes' element content must be structured.

        An aspect of XHTML validity is that the content is declared to be in
        the XML namespace for XHTML 1.0.  There is more than one way in which
        this can be done in XML.  In particular, a model might not contain the
        declaration within the 'notes' or 'message' subelement itself, but
        might instead place the declaration on an enclosing element and use an
        XML namespace prefix within the 'notes' element to refer to it.  In
        other words, the following is valid:

          <sbml xmlns='http://www.sbml.org/sbml/level2/version3' level='2' version='3'
                xmlns:xhtml='http://www.w3.org/1999/xhtml'>
            <model>
              <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.</xhtml:p>
                </xhtml:body>
              </notes>
            ... rest of model ...
          </sbml>

        Contrast the above with the following, self-contained version, which
        places the XML namespace declaration within the <notes> element
        itself:

          <sbml xmlns='http://www.sbml.org/sbml/level2/version3' level='2' version='3'>
            <model>
              <notes>
                <html xmlns='http://www.w3.org/1999/xhtml'>
                  <head>
                    <title/>
                  </head>
                  <body>
                    <center><h2>A Simple Mitotic Oscillator</h2></center>
                    <p>A minimal cascade model for the mitotic oscillator.</p>
                  </body>
                </html>
              </notes>
            ... rest of model ...
          </sbml>

        Both of the above are valid XML.  The purpose of the 'sbmlns' argument
        to this method is to allow callers to check the validity of 'notes'
        and 'message' subelements whose XML namespace declarations have been
        put elsewhere in the manner illustrated above.  Callers can can pass
        in the SBMLNamespaces object of a higher-level model component if the
        XMLNode object does not itself have the XML namespace declaration for
        XHTML 1.0.

        Parameter 'xhtml' is the XMLNode to be checked for conformance.
        Parameter 'sbmlns' is the SBMLNamespaces associated with the object.

        Returns 'True' if the XMLNode content conforms, 'False' otherwise.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        return _libsbml.SyntaxChecker_hasExpectedXHTMLSyntax(xhtml, sbmlns)

    hasExpectedXHTMLSyntax = staticmethod(hasExpectedXHTMLSyntax)

    def isValidInternalSId(sid):
        """
        isValidInternalSId(string sid) -> bool


        Internal implementation method.

        """
        return _libsbml.SyntaxChecker_isValidInternalSId(sid)

    isValidInternalSId = staticmethod(isValidInternalSId)

    def isValidInternalUnitSId(sid):
        """
        isValidInternalUnitSId(string sid) -> bool


        Internal implementation method.

        """
        return _libsbml.SyntaxChecker_isValidInternalUnitSId(sid)

    isValidInternalUnitSId = staticmethod(isValidInternalUnitSId)

    def __init__(self):
        """
        __init__(SyntaxChecker self) -> SyntaxChecker


        @internal

        """
        this = _libsbml.new_SyntaxChecker()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_SyntaxChecker
    __del__ = lambda self: None
SyntaxChecker_swigregister = _libsbml.SyntaxChecker_swigregister
SyntaxChecker_swigregister(SyntaxChecker)

def SyntaxChecker_isValidSBMLSId(sid):
    """
    SyntaxChecker_isValidSBMLSId(string sid) -> bool


    Returns 'True' or 'False' depending on whether the argument string
    conforms to the syntax of SBML identifiers.

    In SBML, identifiers that are the values of 'id' attributes on
    objects must conform to a data type called SId in the SBML
    specifications.  LibSBML does not provide an explicit SId data type;
    it uses ordinary character strings, which is easier for applications
    to support.  (LibSBML does, however, test for identifier validity at
    various times, such as when reading in models from files and data
    streams.)

    This method provides programs with the ability to test explicitly that
    the identifier strings they create conform to the SBML identifier
    syntax.

    Parameter 'sid' is string to be checked for conformance to SBML
    identifier syntax.

    Returns 'True' if the string conforms to type SBML data type SId,
    'False' otherwise.

    The identifier given by an object's 'id' attribute value is used to
    identify the object within the SBML model definition. Other objects
    can refer to the component using this identifier.  The data type of
    'id' is always SId or a type derived from that, such as UnitSId,
    depending on the object in  question.  All data types are defined as
    follows:

      letter ::= 'a'..'z','A'..'Z'
      digit  ::= '0'..'9'
      idChar ::= letter | digit | '_'
      SId    ::= ( letter | '_' ) idChar*

    The equality of SId and SId-derived values in SBML is determined by
    an exact character sequence match; i.e., comparisons of these
    identifiers must be performed in a case-sensitive manner.  This
    applies to all uses of SId,  SIdRef, and derived types.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    See also SyntaxChecker.isValidUnitSId() , SyntaxChecker.isValidXMLID()
    .

    """
    return _libsbml.SyntaxChecker_isValidSBMLSId(sid)

def SyntaxChecker_isValidXMLID(id):
    """
    SyntaxChecker_isValidXMLID(string id) -> bool


    Returns 'True' or 'False' depending on whether the argument string
    conforms to the XML data type ID.

    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
    XML ID, the XML identifier type, which means each 'metaid' value must
    be globally unique within an SBML file.  The latter point is
    important, because the uniqueness criterion applies across any
    attribute with type ID anywhere in the file, not just the 'metaid'
    attribute used by SBML---something to be aware of if your application-
    specific XML content inside the 'annotation' subelement happens to use
    the XML ID type.  Although SBML itself specifies the use of XML ID
    only for the 'metaid' attribute, SBML-compatible applications should
    be careful if they use XML ID's in XML portions of a model that are
    not defined by SBML, such as in the application-specific content of
    the 'annotation' subelement.  Finally, note that LibSBML does not
    provide an explicit XML ID data type; it uses ordinary character
    strings, which is easier for applications to support.

    This method provides programs with the ability to test explicitly that
    the identifier strings they create conform to the SBML identifier
    syntax.

    Parameter 'id' is string to be checked for conformance to the syntax
    of XML ID.

    Returns 'True' if the string is a syntactically-valid value for the
    XML type ID, 'False' otherwise.

    Note: The following is a summary of the definition of the XML 1.0 data
    type ID.  We express the syntax using an extended form of BNF
    notation: <p> <nobr>NCNameChar ::= letter | digit | '.' | '-' | '_' |
    ':' | CombiningChar | Extender </nobr> ID ::= ( letter | '_' | ':' )
    NCNameChar* <p> The characters ( and ) are used for grouping, the
    character * means "zero or more times", and the character |
    indicates logical "or". The production letter consists of the basic
    upper and lower case alphabetic characters of the Latin alphabet along
    with a large number of related characters defined by Unicode 2.0;
    similarly, the production digit consists of the numerals 0..9 along
    with related Unicode 2.0 characters.  The CombiningChar production is
    a list of characters that add such things as accents to the preceding
    character. (For example, the Unicode character \#x030A when combined
    with a produces a.)  The Extender production is a list of characters
    that extend the shape of the preceding character.  Please consult the
    XML 1.0 specification for the complete definitions of letter, digit,
    CombiningChar, and Extender. <p>

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    See also SyntaxChecker.isValidSBMLSId() ,
    SyntaxChecker.isValidUnitSId() .

    """
    return _libsbml.SyntaxChecker_isValidXMLID(id)

def SyntaxChecker_isValidXMLanyURI(uri):
    """
    SyntaxChecker_isValidXMLanyURI(string uri) -> bool


    Returns 'True' or 'False' depending on whether the 'uri' argument
    string conforms to the XML data type anyURI.

    Type anyURI is defined by XML Schema 1.0. It is a character string
    data type whose values are interpretable as URIs (Universal Resource
    Identifiers) as described by the W3C document RFC 3986.  LibSBML does
    not provide an explicit XML anyURI data type; it uses ordinary
    character strings, which is easier for applications to support.
    LibSBML does, however, test for anyURI validity at various times, such
    as when reading in models from files and data streams.

    This method provides programs with the ability to test explicitly that
    the strings they create conform to the XML anyURI syntax.

    Parameter 'uri' is string to be checked for conformance to the syntax
    of anyURI.

    Returns 'True' if the string is a syntactically-valid value for the
    XML type anyURI,  'False' otherwise.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.SyntaxChecker_isValidXMLanyURI(uri)

def SyntaxChecker_isValidUnitSId(units):
    """
    SyntaxChecker_isValidUnitSId(string units) -> bool


    Returns 'True' or 'False' depending on whether the argument string
    conforms to the syntax of SBML unit identifiers.

    In SBML, the identifiers of units (of both the predefined units and
    user-defined units) must conform to a data type called UnitSId in the
    SBML specifications.  LibSBML does not provide an explicit UnitSId
    data type; it uses ordinary character strings, which is easier for
    applications to support. LibSBML does, however, test for identifier
    validity at various times, such as when reading in models from files
    and data streams.

    This method provides programs with the ability to test explicitly that
    the identifier strings they create conform to the SBML identifier
    syntax.

    Parameter 'units' is string to be checked for conformance to SBML unit
    identifier syntax.

    Returns 'True' if the string conforms to type SBML data type UnitSId,
    'False' otherwise.

    Note: The following is a summary of the definition of the SBML
    identifier type UnitSId, which defines the permitted syntax of
    identifiers. We express the syntax using an extended form of BNF
    notation: <p> letter ::= 'a'..'z','A'..'Z' digit  ::= '0'..'9' idChar
    ::= letter | digit | '_' SId    ::= ( letter | '_' ) idChar* <p> The
    characters ( and ) are used for grouping, the character * "zero or
    more times", and the character | indicates logical "or".  The
    equality of SBML unit 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 unit identifiers in an SBML model.  Please consult the
    SBML specifications for the exact formulations. <p>

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    See also SyntaxChecker.isValidSBMLSId() , SyntaxChecker.isValidXMLID()
    .

    """
    return _libsbml.SyntaxChecker_isValidUnitSId(units)

def SyntaxChecker_hasExpectedXHTMLSyntax(xhtml, sbmlns=None):
    """
    hasExpectedXHTMLSyntax(XMLNode xhtml, SBMLNamespaces sbmlns=None) -> bool
    SyntaxChecker_hasExpectedXHTMLSyntax(XMLNode xhtml) -> bool


    Returns 'True' or 'False' depending on whether the given XMLNode
    object contains valid XHTML content.

    The optional SBML element named 'notes', present on every major SBML
    component type (and in SBML Level 3, the 'message' subelement of
    Constraint), 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 conform to the definition of XHTML 1.0.
    However, the content cannot be entirely free-form; it must satisfy
    certain requirements defined in the SBML specifications for specific
    SBML Levels.  To help verify the formatting of 'notes' content,
    libSBML provides the static utility method
    SyntaxChecker.hasExpectedXHTMLSyntax(); this method implements a
    verification process that lets callers check whether the content of a
    given XMLNode object conforms to the SBML requirements for 'notes' and
    'message' structure.  Developers are urged to consult the appropriate
    SBML specification document for the Level and Version of their model
    for more in-depth explanations of using 'notes' in SBML.  The SBML
    Level 2 and 3 specifications have considerable detail about how
    'notes' element content must be structured.

    An aspect of XHTML validity is that the content is declared to be in
    the XML namespace for XHTML 1.0.  There is more than one way in which
    this can be done in XML.  In particular, a model might not contain the
    declaration within the 'notes' or 'message' subelement itself, but
    might instead place the declaration on an enclosing element and use an
    XML namespace prefix within the 'notes' element to refer to it.  In
    other words, the following is valid:

      <sbml xmlns='http://www.sbml.org/sbml/level2/version3' level='2' version='3'
            xmlns:xhtml='http://www.w3.org/1999/xhtml'>
        <model>
          <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.</xhtml:p>
            </xhtml:body>
          </notes>
        ... rest of model ...
      </sbml>

    Contrast the above with the following, self-contained version, which
    places the XML namespace declaration within the <notes> element
    itself:

      <sbml xmlns='http://www.sbml.org/sbml/level2/version3' level='2' version='3'>
        <model>
          <notes>
            <html xmlns='http://www.w3.org/1999/xhtml'>
              <head>
                <title/>
              </head>
              <body>
                <center><h2>A Simple Mitotic Oscillator</h2></center>
                <p>A minimal cascade model for the mitotic oscillator.</p>
              </body>
            </html>
          </notes>
        ... rest of model ...
      </sbml>

    Both of the above are valid XML.  The purpose of the 'sbmlns' argument
    to this method is to allow callers to check the validity of 'notes'
    and 'message' subelements whose XML namespace declarations have been
    put elsewhere in the manner illustrated above.  Callers can can pass
    in the SBMLNamespaces object of a higher-level model component if the
    XMLNode object does not itself have the XML namespace declaration for
    XHTML 1.0.

    Parameter 'xhtml' is the XMLNode to be checked for conformance.
    Parameter 'sbmlns' is the SBMLNamespaces associated with the object.

    Returns 'True' if the XMLNode content conforms, 'False' otherwise.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

    Note: Owing to the way that language interfaces are created in
    libSBML, this documentation may show methods that define default
    values for parameters with text that has the form parameter = value.
    This is not to be intepreted as a Python keyword argument; the use of
    a parameter name followed by an equals sign followed by a value is
    only meant to indicate a default value if the argument is not provided
    at all.  It is not a keyword in the Python sense.

    """
    return _libsbml.SyntaxChecker_hasExpectedXHTMLSyntax(xhtml, sbmlns)

def SyntaxChecker_isValidInternalSId(sid):
    """
    SyntaxChecker_isValidInternalSId(string sid) -> bool


    Internal implementation method.

    """
    return _libsbml.SyntaxChecker_isValidInternalSId(sid)

def SyntaxChecker_isValidInternalUnitSId(sid):
    """
    SyntaxChecker_isValidInternalUnitSId(string sid) -> bool


    Internal implementation method.

    """
    return _libsbml.SyntaxChecker_isValidInternalUnitSId(sid)

class StoichiometryMath(SBase):
    """

    Stochiometry expressions in SBML Level 2 reactions.

    Stoichiometries in SBML Level 2
    ======================================================================

    In SBML Level 2, product and reactant stoichiometries can be specified
    using either the 'stoichiometry' attribute or a 'stoichiometryMath'
    element in a SpeciesReference object.  The 'stoichiometry' attribute
    is of type 'float' and should contain values greater than zero (0).
    The 'stoichiometryMath' element is implemented as an element
    containing a MathML expression.  These two are mutually exclusive;
    only one of 'stoichiometry' or 'stoichiometryMath' should be defined
    in a given SpeciesReference instance.  When neither the attribute nor
    the element is present, the value of 'stoichiometry' in the enclosing
    SpeciesReference instance defaults to '1.'

    For maximum interoperability, SpeciesReference's 'stoichiometry'
    attribute should be used in preference to 'stoichiometryMath' when a
    species' stoichiometry is a simple scalar number (integer or decimal).
    When the stoichiometry is a rational number, or when it is a more
    complicated formula, 'stoichiometryMath' must be used.  The MathML
    expression in 'stoichiometryMath' may also refer to identifiers of
    entities in a model (except reaction identifiers).  However, the only
    species identifiers that can be used in 'stoichiometryMath' are those
    referenced in the enclosing Reaction's list of reactants, products and
    modifiers.

    The 'stoichiometry' attribute and the 'stoichiometryMath' element,
    when either is used, is each interpreted as a factor applied to the
    reaction rate to produce the rate of change of the species identified
    by the 'species' attribute in the enclosing SpeciesReference.  This is
    the normal interpretation of a stoichiometry, but in SBML, one
    additional consideration has to be taken into account.  The reaction
    rate, which is the result of the KineticLaw's 'math' element, is
    always in the model's substance per time units.  However, the rate of
    change of the species will involve the species' substance units (i.e.,
    the units identified by the Species object's 'substanceUnits'
    attribute), and these units may be different from the model's default
    substance units.  If the units are different, the stoichiometry must
    incorporate a conversion factor for converting the model's substance
    units to the species' substance units.  The conversion factor is
    assumed to be included in the scalar value of the 'stoichiometry'
    attribute if 'stoichiometry' is used.  If instead 'stoichiometryMath'
    is used, then the product of the model's 'substance' units times the
    'stoichiometryMath' units must match the substance units of the
    species.  Note that in either case, if the species' units and the
    model's default substance units are the same, the stoichiometry ends
    up being a dimensionless number and equivalent to the standard
    chemical stoichiometry found in textbooks.  Examples and more
    explanations of this are given in the SBML specification.

    The following is a simple example of a species reference for species
    ''X0',' with stoichiometry '2,' in a list of reactants within a
    reaction having the identifier ''J1':'

       <model>
           ...
           <listOfReactions>
               <reaction id='J1'>
                   <listOfReactants>
                       <speciesReference species='X0' stoichiometry='2'>
                   </listOfReactants>
                   ...
               </reaction>
               ...
           </listOfReactions>
           ...
       </model>

    The following is a more complex example of a species reference for
    species ''X0',' with a stoichiometry formula consisting of a rational
    number:

       <model>
           ...
           <listOfReactions>
               <reaction id='J1'>
                   <listOfReactants>
                       <speciesReference species='X0'>
                           <stoichiometryMath>
                               <math xmlns='http://www.w3.org/1998/Math/MathML'> 
                                   <cn type='rational'> 3 <sep/> 2 </cn>
                               </math>
                           </stoichiometryMath>
                       </speciesReference>
                   </listOfReactants>
                   ...
               </reaction>
               ...
           </listOfReactions>
           ...
       </model>

    Additional discussions of stoichiometries and implications for species
    and reactions are included in the documentation of SpeciesReference
    class.

    Stoichiometries in SBML Level 3
    ======================================================================

    The StoichiometryMath construct is not defined in SBML Level 3.
    Instead, Level 3 defines the identifier of SpeciesReference objects as
    a stand-in for the stoichiometry of the reactant or product being
    referenced, and allows that identifier to be used elsewhere in SBML
    models, including (for example) InitialAssignment objects.  This makes
    it possible to achieve the same effect as StoichiometryMath, but with
    other SBML objects.  For instance, to produce a stoichiometry value
    that is a rational number, a model can use InitialAssignment to assign
    the identifier of a SpeciesReference object to a MathML expression
    evaluating to a rational number.  This is analogous to the same way
    that, in Level 2, the model would use StoichiometryMath with a MathML
    expression evaluating to a rational number.

    In SBML Level 2, the stoichiometry of a reactant or product is a
    combination of both a biochemical stoichiometry (meaning, the standard
    stoichiometry of a species in a reaction) and any necessary unit
    conversion factors. The introduction of an explicit attribute on the
    Species object for a conversion factor allows Level 3 to avoid having
    to overload the meaning of stoichiometry.  In Level 3, the
    stoichiometry given by a SpeciesReference object in a reaction is a
    'proper' biochemical stoichiometry, meaning a dimensionless number
    free of unit conversions.

    See also SpeciesReference, Reaction.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, StoichiometryMath, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, StoichiometryMath, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_StoichiometryMath
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(StoichiometryMath self, unsigned int level, unsigned int version) -> StoichiometryMath
        __init__(StoichiometryMath self, SBMLNamespaces sbmlns) -> StoichiometryMath
        __init__(StoichiometryMath self, StoichiometryMath orig) -> StoichiometryMath


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            StoichiometryMath(SBMLNamespaces sbmlns)

        Creates a new StoichiometryMath object using the given SBMLNamespaces
        object 'sbmlns'.

        The SBMLNamespaces object encapsulates SBML Level/Version/namespaces
        information.  It is used to communicate the SBML Level, Version, and
        (in Level 3) packages used in addition to SBML Level 3 Core.  A common
        approach to using libSBML's SBMLNamespaces facilities is to create an
        SBMLNamespaces object somewhere in a program once, then hand that
        object as needed to object constructors that accept SBMLNamespaces as
        arguments.

        Parameter 'sbmlns' is an SBMLNamespaces object.

        Throws SBMLConstructorException: Thrown if the given 'sbmlns' is
        inconsistent or incompatible with this object.

        Note: The StoichiometryMath construct exists only in SBML Level 2. It
        is an optional construct available for defining the stoichiometries of
        reactants and products in Reaction objects.  Note that a different
        mechanism is used in SBML Level 3, where StoichiometryMath is not
        available.  Please consult the top of this libSBML StoichiometryMath
        documentation for more information about the differences between SBML
        Level 2 and 3 with respect to stoichiometries.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            StoichiometryMath(long level, long version)

        Creates a new StoichiometryMath object using the given SBML 'level'
        values.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        StoichiometryMath.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this StoichiometryMath.

        Throws SBMLConstructorException: Thrown if the given 'level' and
        'version' combination are invalid or if this object is incompatible
        with the given level and version.

        Note: The StoichiometryMath construct exists only in SBML Level 2. It
        is an optional construct available for defining the stoichiometries of
        reactants and products in Reaction objects.  Note that a different
        mechanism is used in SBML Level 3, where StoichiometryMath is not
        available.  Please consult the top of this libSBML StoichiometryMath
        documentation for more information about the differences between SBML
        Level 2 and 3 with respect to stoichiometries.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            StoichiometryMath(StoichiometryMath orig)

        Copy constructor; creates a copy of this StoichiometryMath.

        Parameter 'orig' is the object to copy.

        """
        this = _libsbml.new_StoichiometryMath(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(StoichiometryMath self) -> StoichiometryMath


        Creates and returns a deep copy of this StoichiometryMath object.

        Returns the (deep) copy of this StoichiometryMath object.

        """
        return _libsbml.StoichiometryMath_clone(self)


    def getMath(self):
        """
        getMath(StoichiometryMath self) -> ASTNode


        Retrieves the mathematical formula within this StoichiometryMath and
        return it as an AST.

        Returns the math of this StoichiometryMath, or 'None' if the math is
        not set.

        Note: The StoichiometryMath construct exists only in SBML Level 2. It
        is an optional construct available for defining the stoichiometries of
        reactants and products in Reaction objects.  Note that a different
        mechanism is used in SBML Level 3, where StoichiometryMath is not
        available.  Please consult the top of this libSBML StoichiometryMath
        documentation for more information about the differences between SBML
        Level 2 and 3 with respect to stoichiometries.

        """
        return _libsbml.StoichiometryMath_getMath(self)


    def isSetMath(self):
        """
        isSetMath(StoichiometryMath self) -> bool


        Predicate to test whether the math for this StoichiometryMath object
        is set.

        Returns 'True' if the formula (meaning the 'math' subelement) of this
        StoichiometryMath is set, 'False' otherwise.

        Note: The StoichiometryMath construct exists only in SBML Level 2. It
        is an optional construct available for defining the stoichiometries of
        reactants and products in Reaction objects.  Note that a different
        mechanism is used in SBML Level 3, where StoichiometryMath is not
        available.  Please consult the top of this libSBML StoichiometryMath
        documentation for more information about the differences between SBML
        Level 2 and 3 with respect to stoichiometries.

        """
        return _libsbml.StoichiometryMath_isSetMath(self)


    def setMath(self, math):
        """
        setMath(StoichiometryMath self, ASTNode math) -> int


        Sets the 'math' expression of this StoichiometryMath instance to a
        copy of the given ASTNode.

        Parameter 'math' is an ASTNode representing a formula tree.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_OBJECT

        Note: The StoichiometryMath construct exists only in SBML Level 2. It
        is an optional construct available for defining the stoichiometries of
        reactants and products in Reaction objects.  Note that a different
        mechanism is used in SBML Level 3, where StoichiometryMath is not
        available.  Please consult the top of this libSBML StoichiometryMath
        documentation for more information about the differences between SBML
        Level 2 and 3 with respect to stoichiometries.

        """
        return _libsbml.StoichiometryMath_setMath(self, math)


    def getDerivedUnitDefinition(self, *args):
        """
        getDerivedUnitDefinition(StoichiometryMath self) -> UnitDefinition
        getDerivedUnitDefinition(StoichiometryMath self) -> UnitDefinition


        Calculates and returns a UnitDefinition object that expresses the
        units returned by the math expression in this StoichiometryMath
        object.

        The units are calculated based on the mathematical expression in the
        StoichiometryMath and the model quantities referenced by <ci> elements
        used within that expression.  The
        StoichiometryMath.getDerivedUnitDefinition() method returns the
        calculated units.

        Note that the functionality that facilitates unit analysis depends  on
        the model as a whole.  Thus, in cases where the object has not  been
        added to a model or the model itself is incomplete, unit analysis is
        not possible and this method will return 'None.'

        Returns a UnitDefinition that expresses the units of the math,  or
        'None' if one cannot be constructed.

        WARNING:

        Note that it is possible the 'math' expression in the
        StoichiometryMath instance contains literal numbers or parameters with
        undeclared units.  In those cases, it is not possible to calculate the
        units of the overall expression without making assumptions.  LibSBML
        does not make assumptions about the units, and
        StoichiometryMath.getDerivedUnitDefinition() only returns the units as
        far as it is able to determine them.  For example, in an expression X
        + Y, if X has unambiguously-defined units and Y does not, it will
        return the units of X.  When using this method, it is critical that
        callers also invoke the method
        StoichiometryMath.containsUndeclaredUnits() to determine whether this
        situation holds.  Callers should take suitable action in those
        situations.

        See also containsUndeclaredUnits().

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


    def containsUndeclaredUnits(self, *args):
        """
        containsUndeclaredUnits(StoichiometryMath self) -> bool
        containsUndeclaredUnits(StoichiometryMath self) -> bool


        Predicate returning 'True' if the math expression of this
        StoichiometryMath object contains literal numbers or parameters with
        undeclared units.

        The StoichiometryMath.getDerivedUnitDefinition() method returns what
        libSBML computes the units of the Stoichiometry to be, to the extent
        that libSBML can compute them.  However, if the expression contains
        literal numbers or parameters with undeclared units, libSBML may not
        be able to compute the full units of the expression and will only
        return what it can compute.  Callers should always use
        StoichiometryMath.containsUndeclaredUnits() when using
        StoichiometryMath.getDerivedUnitDefinition() to decide whether the
        returned units may be incomplete.

        Returns 'True' if the math expression of this StoichiometryMath
        includes numbers/parameters with undeclared units, 'False' otherwise.

        Note: A return value of 'True' indicates that the UnitDefinition
        returned by StoichiometryMath.getDerivedUnitDefinition() may not
        accurately represent the units of the expression.

        See also getDerivedUnitDefinition().

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


    def getTypeCode(self):
        """
        getTypeCode(StoichiometryMath self) -> int


        Returns the libSBML type code of this object instance.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_STOICHIOMETRY_MATH
        (default).

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.StoichiometryMath_getTypeCode(self)


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


        Returns the XML element name of this object, which for
        StoichiometryMath, is always ''stoichiometryMath'.'

        Returns the name of this element, i.e., ''stoichiometryMath'.'

        """
        return _libsbml.StoichiometryMath_getElementName(self)


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


        Predicate returning 'True' if all the required elements for this
        StoichiometryMath object have been set.

        Note: The required elements for a StoichiometryMath object are:

        * 'math'

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

        """
        return _libsbml.StoichiometryMath_hasRequiredElements(self)


    def removeFromParentAndDelete(self):
        """
        removeFromParentAndDelete(StoichiometryMath self) -> int


        Finds this StoichiometryMath's SpeciesReference parent and calls
        unsetStoichiometryMath() on it, indirectly deleting itself.

        Overridden from the SBase function since the parent is not a ListOf.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.StoichiometryMath_removeFromParentAndDelete(self)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(StoichiometryMath self, string oldid, string newid)


        Replaces all uses of a given 'SIdRef' type attribute value with
        another value.

        In SBML, object identifiers are of a data type called SId. In SBML
        Level 3, an explicit data type called SIdRef was introduced for
        attribute values that refer to SId values; in previous Levels of SBML,
        this data type did not exist and attributes were simply described to
        as 'referring to an identifier', but the effective data type was the
        same as SIdRef in Level 3.  These and other methods of libSBML refer
        to the type SIdRef for all Levels of SBML, even if the corresponding
        SBML specification did not explicitly name the data type.

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas in MathML content, comparing the referenced
        identifiers to the value of 'oldid'.  If any matches are found, the
        matching values are replaced with 'newid'.  The method does not
        descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.StoichiometryMath_renameSIdRefs(self, oldid, newid)


    def renameUnitSIdRefs(self, oldid, newid):
        """
        renameUnitSIdRefs(StoichiometryMath self, string oldid, string newid)


        Replaces all uses of a given 'UnitSIdRef' type attribute value with
        another value.

        In SBML, unit definitions have identifiers of type UnitSId.  In SBML
        Level 3, an explicit data type called UnitSIdRef was introduced for
        attribute values that refer to UnitSId values; in previous Levels of
        SBML, this data type did not exist and attributes were simply
        described to as 'referring to a unit identifier', but the effective
        data type was the same as UnitSIdRef in Level 3.  These and other
        methods of libSBML refer to the type UnitSIdRef for all Levels of
        SBML, even if the corresponding SBML specification did not explicitly
        name the data type.

        This method works by looking at all unit identifier attribute values
        (including, if appropriate, inside mathematical formulas), comparing
        the referenced unit identifiers to the value of 'oldid'.  If any
        matches are found, the matching values are replaced with 'newid'.  The
        method does not descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.StoichiometryMath_renameUnitSIdRefs(self, oldid, newid)


    def replaceSIDWithFunction(self, id, function):
        """
        replaceSIDWithFunction(StoichiometryMath self, string id, ASTNode function)


        Internal implementation method.

        """
        return _libsbml.StoichiometryMath_replaceSIDWithFunction(self, id, function)

StoichiometryMath_swigregister = _libsbml.StoichiometryMath_swigregister
StoichiometryMath_swigregister(StoichiometryMath)

class SBMLNamespaces(_object):
    """

    Set of SBML Level + Version + namespace triples.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    There are differences in the definitions of components between
    different SBML Levels, as well as Versions within Levels.  For
    example, the 'sboTerm' attribute was not introduced until Level 2
    Version 2, and then only on certain component classes; the SBML Level
    2 Version 3 specification moved the 'sboTerm' attribute to the SBase
    class, thereby allowing nearly all components to have SBO annotations.
    As a result of differences such as those, libSBML needs to track the
    SBML Level and Version of every object created.

    The purpose of the SBMLNamespaces object class is to make it easier to
    communicate SBML Level and Version data between libSBML constructors
    and other methods.  The SBMLNamespaces object class tracks 3-tuples
    (triples) consisting of SBML Level, Version, and the corresponding
    SBML XML namespace.

    The plural name (SBMLNamespaces) is not a mistake, because in SBML
    Level 3, objects may have extensions added by Level 3 packages used by
    a given model and therefore may have multiple namespaces associated
    with them; however, until the introduction of SBML Level 3, the
    SBMLNamespaces object only records one SBML Level/Version/namespace
    combination at a time.  Most constructors for SBML objects in libSBML
    take a SBMLNamespaces object as an argument, thereby allowing the
    constructor to produce the proper combination of attributes and other
    internal data structures for the given SBML Level and Version.

    """

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLNamespaces, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SBMLNamespaces, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_SBMLNamespaces
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(SBMLNamespaces self, unsigned int level, unsigned int version) -> SBMLNamespaces
        __init__(SBMLNamespaces self, unsigned int level) -> SBMLNamespaces
        __init__(SBMLNamespaces self) -> SBMLNamespaces
        __init__(SBMLNamespaces self, unsigned int level, unsigned int version, string pkgName, unsigned int pkgVersion, string pkgPrefix) -> SBMLNamespaces
        __init__(SBMLNamespaces self, unsigned int level, unsigned int version, string pkgName, unsigned int pkgVersion) -> SBMLNamespaces
        __init__(SBMLNamespaces self, SBMLNamespaces orig) -> SBMLNamespaces


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            SBMLNamespaces(SBMLNamespaces orig)

        Copy constructor; creates a copy of a SBMLNamespaces.

        Parameter 'orig' is the SBMLNamespaces instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            SBMLNamespaces(long level, long version, string &pkgName,
        long pkgVersion, string pkgPrefix = '')

        (For extensions) Creates a new SBMLNamespaces object corresponding to
        the combination of (1) the given SBML 'level' and 'version', and (2)
        the given 'package' with the 'package' 'version'.

        SBMLNamespaces objects are used in libSBML to communicate SBML Level
        and Version data between constructors and other methods.  The
        SBMLNamespaces object class holds triples consisting of SBML Level,
        Version, and the corresponding SBML XML namespace.  Most constructors
        for SBML objects in libSBML take a SBMLNamespaces object as an
        argument, thereby allowing the constructor to produce the proper
        combination of attributes and other internal data structures for the
        given SBML Level and Version.

        The plural name (SBMLNamespaces) is not a mistake, because in SBML
        Level 3, objects may have extensions added by Level 3 packages used by
        a given model and therefore may have multiple namespaces associated
        with them.  In SBML Levels below Level 3, the SBMLNamespaces object
        only records one SBML Level/Version/namespace combination at a time.
        Most constructors for SBML objects in libSBML take a SBMLNamespaces
        object as an argument, thereby allowing the constructor to produce the
        proper combination of attributes and other internal data structures
        for the given SBML Level and Version.

        Parameter 'level' is the SBML Level. Parameter 'version' is the SBML
        Version. Parameter 'pkgName' is the string of package name (e.g.
        'layout', 'multi'). Parameter 'pkgVersion' is the package version.
        Parameter 'pkgPrefix' is the prefix of the package namespace (e.g.
        'layout', 'multi') to be added. The package's name will be used if the
        given string is empty (default).

        Throws SBMLExtensionException: if the extension module that supports
        the combination of the given SBML Level, SBML Version, package name,
        and package version has not been registered with libSBML.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            SBMLNamespaces(long level = SBML_DEFAULT_LEVEL, long version
        = SBML_DEFAULT_VERSION)

        Creates a new SBMLNamespaces object corresponding to the given SBML
        'level' and 'version'.

        SBMLNamespaces objects are used in libSBML to communicate SBML Level
        and Version data between constructors and other methods.  The
        SBMLNamespaces object class holds triples consisting of SBML Level,
        Version, and the corresponding SBML XML namespace.  Most constructors
        for SBML objects in libSBML take a SBMLNamespaces object as an
        argument, thereby allowing the constructor to produce the proper
        combination of attributes and other internal data structures for the
        given SBML Level and Version.

        The plural name (SBMLNamespaces) is not a mistake, because in SBML
        Level 3, objects may have extensions added by Level 3 packages used by
        a given model and therefore may have multiple namespaces associated
        with them.  In SBML Levels below Level 3, the SBMLNamespaces object
        only records one SBML Level/Version/namespace combination at a time.
        Most constructors for SBML objects in libSBML take a SBMLNamespaces
        object as an argument, thereby allowing the constructor to produce the
        proper combination of attributes and other internal data structures
        for the given SBML Level and Version.

        Parameter 'level' is the SBML level. Parameter 'version' is the SBML
        version.

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        this = _libsbml.new_SBMLNamespaces(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(SBMLNamespaces self) -> SBMLNamespaces


        Creates and returns a deep copy of this SBMLNamespaces object.

        Returns the (deep) copy of this SBMLNamespaces object.

        """
        return _libsbml.SBMLNamespaces_clone(self)


    def getSBMLNamespaceURI(level, version):
        """
        getSBMLNamespaceURI(unsigned int level, unsigned int version) -> string


        Returns a string representing the SBML XML namespace for the  given
        'level' and 'version' of SBML.

        Parameter 'level' is the SBML level. Parameter 'version' is the SBML
        version.

        Returns a string representing the SBML namespace that reflects the
        SBML Level and Version specified.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.SBMLNamespaces_getSBMLNamespaceURI(level, version)

    getSBMLNamespaceURI = staticmethod(getSBMLNamespaceURI)

    def getSupportedNamespaces():
        """
        getSupportedNamespaces() -> List const *


        Returns a list of all supported SBMLNamespaces in this version of
        libsbml.

        Returns a list with supported SBML namespaces.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.SBMLNamespaces_getSupportedNamespaces()

    getSupportedNamespaces = staticmethod(getSupportedNamespaces)

    def freeSBMLNamespaces(supportedNS):
        """
        freeSBMLNamespaces(List * supportedNS)


        Frees the list of supported namespaces as generated by
        getSupportedNamespaces().

        Parameter 'supportedNS' is the list to be freed.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.SBMLNamespaces_freeSBMLNamespaces(supportedNS)

    freeSBMLNamespaces = staticmethod(freeSBMLNamespaces)

    def getURI(self):
        """
        getURI(SBMLNamespaces self) -> string


        Returns a string representing the SBML XML namespace of this object.

        Returns a string representing the SBML namespace that reflects the
        SBML Level and Version of this object.

        """
        return _libsbml.SBMLNamespaces_getURI(self)


    def getLevel(self, *args):
        """
        getLevel(SBMLNamespaces self) -> unsigned int
        getLevel(SBMLNamespaces self) -> unsigned int


        Get the SBML Level of this SBMLNamespaces object.

        Returns the SBML Level of this SBMLNamespaces object.

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


    def getVersion(self, *args):
        """
        getVersion(SBMLNamespaces self) -> unsigned int
        getVersion(SBMLNamespaces self) -> unsigned int


        Get the SBML Version of this SBMLNamespaces object.

        Returns the SBML Version of this SBMLNamespaces object.

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


    def getNamespaces(self, *args):
        """
        getNamespaces(SBMLNamespaces self) -> XMLNamespaces
        getNamespaces(SBMLNamespaces self) -> XMLNamespaces


        Get the XML namespaces list for this SBMLNamespaces object.

        SBMLNamespaces objects are used in libSBML to communicate SBML Level
        and Version data between constructors and other methods.  The
        SBMLNamespaces object class holds triples consisting of SBML Level,
        Version, and the corresponding SBML XML namespace.  Most constructors
        for SBML objects in libSBML take a SBMLNamespaces object as an
        argument, thereby allowing the constructor to produce the proper
        combination of attributes and other internal data structures for the
        given SBML Level and Version.

        The plural name (SBMLNamespaces) is not a mistake, because in SBML
        Level 3, objects may have extensions added by Level 3 packages used by
        a given model and therefore may have multiple namespaces associated
        with them.  In SBML Levels below Level 3, the SBMLNamespaces object
        only records one SBML Level/Version/namespace combination at a time.
        Most constructors for SBML objects in libSBML take a SBMLNamespaces
        object as an argument, thereby allowing the constructor to produce the
        proper combination of attributes and other internal data structures
        for the given SBML Level and Version.

        Returns the XML namespaces of this SBMLNamespaces object.

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


    def addNamespaces(self, xmlns):
        """
        addNamespaces(SBMLNamespaces self, XMLNamespaces xmlns) -> int


        Add the given XML namespaces list to the set of namespaces within this
        SBMLNamespaces object.

        The following code gives an example of how one could add the XHTML
        namespace to the list of namespaces recorded by the top-level <sbml>
        element of a model.  It gives the new namespace a prefix of html.

          sbmlDoc = None
          try:
            sbmlDoc = SBMLDocument(3, 1)
          except ValueError:
            # Do something to handle exceptional situation.  Candidate
            # causes include invalid combinations of SBML Level and Version
            # (impossible if hardwired as given here), running out of memory, and
            # unknown system exceptions.

          namespaces = sbmlDoc.getNamespaces()
          if namespaces == None:
            # Do something to handle case of no namespaces.

          status = namespaces.add('http://www.w3.org/1999/xhtml', 'html')
          if status != LIBSBML_OPERATION_SUCCESS:
            # Do something to handle failure.

        Parameter 'xmlns' is the XML namespaces to be added.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        """
        return _libsbml.SBMLNamespaces_addNamespaces(self, xmlns)


    def addNamespace(self, uri, prefix):
        """
        addNamespace(SBMLNamespaces self, string uri, string prefix) -> int


        Add an XML namespace (a pair of URI and prefix) to the set of
        namespaces within this SBMLNamespaces object.

        Parameter 'uri' is the XML namespace to be added. Parameter 'prefix'
        is the prefix of the namespace to be added.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        """
        return _libsbml.SBMLNamespaces_addNamespace(self, uri, prefix)


    def removeNamespace(self, uri):
        """
        removeNamespace(SBMLNamespaces self, string uri) -> int


        Removes an XML namespace from the set of namespaces within this
        SBMLNamespaces object.

        Parameter 'uri' is the XML namespace to be added.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INDEX_EXCEEDS_SIZE

        """
        return _libsbml.SBMLNamespaces_removeNamespace(self, uri)


    def addPackageNamespace(self, *args):
        """
        addPackageNamespace(SBMLNamespaces self, string pkgName, unsigned int pkgVersion, string prefix) -> int
        addPackageNamespace(SBMLNamespaces self, string pkgName, unsigned int pkgVersion) -> int


        Add an XML namespace (a pair of URI and prefix) of a package extension
        to the set of namespaces within this SBMLNamespaces object.

        The SBML Level and SBML Version of this object is used.

        Parameter 'pkgName' is the string of package name (e.g. 'layout',
        'multi'). Parameter 'pkgVersion' is the package version. Parameter
        'prefix' is the prefix of the package namespace to be added. The
        package's name will be used if the given string is empty (default).

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        Note: An XML namespace of a non-registered package extension can't be
        added by this function (LIBSBML_INVALID_ATTRIBUTE_VALUE  will be
        returned).

        See also addNamespace().

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

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


    def addPackageNamespaces(self, xmlns):
        """
        addPackageNamespaces(SBMLNamespaces self, XMLNamespaces xmlns) -> int


        Add the XML namespaces of package extensions in the given XMLNamespace
        object to the set of namespaces within this SBMLNamespaces object
        (Non-package XML namespaces are not added by this function).

        Parameter 'xmlns' is the XML namespaces to be added.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        Note: XML namespaces of a non-registered package extensions are not
        added (just ignored) by this function. LIBSBML_INVALID_ATTRIBUTE_VALUE
        will be returned if the given xmlns is 'None.'

        """
        return _libsbml.SBMLNamespaces_addPackageNamespaces(self, xmlns)


    def removePackageNamespace(self, level, version, pkgName, pkgVersion):
        """
        removePackageNamespace(SBMLNamespaces self, unsigned int level, unsigned int version, string pkgName, unsigned int pkgVersion) -> int


        Removes an XML namespace of a package extension from the set of
        namespaces  within this SBMLNamespaces object.

        Parameter 'level' is the SBML level. Parameter 'version' is the SBML
        version. Parameter 'pkgName' is the string of package name (e.g.
        'layout', 'multi'). Parameter 'pkgVersion' is the package version.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_INDEX_EXCEEDS_SIZE

        """
        return _libsbml.SBMLNamespaces_removePackageNamespace(self, level, version, pkgName, pkgVersion)


    def addPkgNamespace(self, *args):
        """
        addPkgNamespace(SBMLNamespaces self, string pkgName, unsigned int pkgVersion, string prefix) -> int
        addPkgNamespace(SBMLNamespaces self, string pkgName, unsigned int pkgVersion) -> int


        Internal implementation method.

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


    def addPkgNamespaces(self, xmlns):
        """
        addPkgNamespaces(SBMLNamespaces self, XMLNamespaces xmlns) -> int


        Internal implementation method.

        """
        return _libsbml.SBMLNamespaces_addPkgNamespaces(self, xmlns)


    def removePkgNamespace(self, level, version, pkgName, pkgVersion):
        """
        removePkgNamespace(SBMLNamespaces self, unsigned int level, unsigned int version, string pkgName, unsigned int pkgVersion) -> int


        Internal implementation method.

        """
        return _libsbml.SBMLNamespaces_removePkgNamespace(self, level, version, pkgName, pkgVersion)


    def isSBMLNamespace(uri):
        """
        isSBMLNamespace(string uri) -> bool


        Predicate returning 'True' if the given URL is one of SBML XML
        namespaces.

        Parameter 'uri' is the URI of namespace.

        Returns 'True' if the 'uri' is one of SBML namespaces, 'False'
        otherwise.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.SBMLNamespaces_isSBMLNamespace(uri)

    isSBMLNamespace = staticmethod(isSBMLNamespace)

    def isValidCombination(self):
        """
        isValidCombination(SBMLNamespaces self) -> bool


        Predicate returning 'True' if the given set of namespaces represent a
        valid set

        Returns 'True' if the set of namespaces is valid, 'False' otherwise.

        """
        return _libsbml.SBMLNamespaces_isValidCombination(self)


    def getPackageName(self):
        """
        getPackageName(SBMLNamespaces self) -> string


        Returns the name of the main package for this namespace.

        Returns the name of the main package for this namespace. 'core' will
        be returned if this namespace is defined in the SBML  core.

        """
        return _libsbml.SBMLNamespaces_getPackageName(self)


    __metaclass__ = AutoProperty


    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

SBMLNamespaces_swigregister = _libsbml.SBMLNamespaces_swigregister
SBMLNamespaces_swigregister(SBMLNamespaces)

def SBMLNamespaces_getSBMLNamespaceURI(level, version):
    """
    SBMLNamespaces_getSBMLNamespaceURI(unsigned int level, unsigned int version) -> string


    Returns a string representing the SBML XML namespace for the  given
    'level' and 'version' of SBML.

    Parameter 'level' is the SBML level. Parameter 'version' is the SBML
    version.

    Returns a string representing the SBML namespace that reflects the
    SBML Level and Version specified.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.SBMLNamespaces_getSBMLNamespaceURI(level, version)

def SBMLNamespaces_getSupportedNamespaces():
    """
    SBMLNamespaces_getSupportedNamespaces() -> List const *


    Returns a list of all supported SBMLNamespaces in this version of
    libsbml.

    Returns a list with supported SBML namespaces.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.SBMLNamespaces_getSupportedNamespaces()

def SBMLNamespaces_freeSBMLNamespaces(supportedNS):
    """
    SBMLNamespaces_freeSBMLNamespaces(List * supportedNS)


    Frees the list of supported namespaces as generated by
    getSupportedNamespaces().

    Parameter 'supportedNS' is the list to be freed.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.SBMLNamespaces_freeSBMLNamespaces(supportedNS)

def SBMLNamespaces_isSBMLNamespace(uri):
    """
    SBMLNamespaces_isSBMLNamespace(string uri) -> bool


    Predicate returning 'True' if the given URL is one of SBML XML
    namespaces.

    Parameter 'uri' is the URI of namespace.

    Returns 'True' if the 'uri' is one of SBML namespaces, 'False'
    otherwise.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.SBMLNamespaces_isSBMLNamespace(uri)

class SBMLTransforms(_object):
    """

    Internal implementation method.

    """

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLTransforms, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SBMLTransforms, name)
    __repr__ = _swig_repr

    def replaceFD(*args):
        """
        replaceFD(ASTNode math, FunctionDefinition fd, IdList idsToExclude=None)
        replaceFD(ASTNode math, FunctionDefinition fd)
        replaceFD(ASTNode math, ListOfFunctionDefinitions lofd, IdList idsToExclude=None)
        replaceFD(ASTNode math, ListOfFunctionDefinitions lofd)
        """
        return _libsbml.SBMLTransforms_replaceFD(*args)

    replaceFD = staticmethod(replaceFD)

    def expandInitialAssignments(m):
        """
        expandInitialAssignments(Model m) -> bool


        Internal implementation method.

        """
        return _libsbml.SBMLTransforms_expandInitialAssignments(m)

    expandInitialAssignments = staticmethod(expandInitialAssignments)

    def evaluateASTNode(node, m=None):
        """
        evaluateASTNode(ASTNode node, Model m=None) -> double
        evaluateASTNode(ASTNode node) -> double


        Internal implementation method.

        """
        return _libsbml.SBMLTransforms_evaluateASTNode(node, m)

    evaluateASTNode = staticmethod(evaluateASTNode)

    def expandL3V2InitialAssignments(m):
        """
        expandL3V2InitialAssignments(Model m) -> bool


        Internal implementation method.

        """
        return _libsbml.SBMLTransforms_expandL3V2InitialAssignments(m)

    expandL3V2InitialAssignments = staticmethod(expandL3V2InitialAssignments)

    def mapComponentValues(m):
        """mapComponentValues(Model m) -> IdList"""
        return _libsbml.SBMLTransforms_mapComponentValues(m)

    mapComponentValues = staticmethod(mapComponentValues)

    def clearComponentValues():
        """clearComponentValues()"""
        return _libsbml.SBMLTransforms_clearComponentValues()

    clearComponentValues = staticmethod(clearComponentValues)

    def nodeContainsId(node, ids):
        """nodeContainsId(ASTNode node, IdList ids) -> bool"""
        return _libsbml.SBMLTransforms_nodeContainsId(node, ids)

    nodeContainsId = staticmethod(nodeContainsId)

    def __init__(self):
        """
        __init__(SBMLTransforms self) -> SBMLTransforms


        Internal implementation method.

        """
        this = _libsbml.new_SBMLTransforms()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_SBMLTransforms
    __del__ = lambda self: None
SBMLTransforms_swigregister = _libsbml.SBMLTransforms_swigregister
SBMLTransforms_swigregister(SBMLTransforms)

def SBMLTransforms_replaceFD(*args):
    """
    replaceFD(ASTNode math, FunctionDefinition fd, IdList idsToExclude=None)
    replaceFD(ASTNode math, FunctionDefinition fd)
    replaceFD(ASTNode math, ListOfFunctionDefinitions lofd, IdList idsToExclude=None)
    SBMLTransforms_replaceFD(ASTNode math, ListOfFunctionDefinitions lofd)
    """
    return _libsbml.SBMLTransforms_replaceFD(*args)

def SBMLTransforms_expandInitialAssignments(m):
    """
    SBMLTransforms_expandInitialAssignments(Model m) -> bool


    Internal implementation method.

    """
    return _libsbml.SBMLTransforms_expandInitialAssignments(m)

def SBMLTransforms_evaluateASTNode(node, m=None):
    """
    evaluateASTNode(ASTNode node, Model m=None) -> double
    SBMLTransforms_evaluateASTNode(ASTNode node) -> double


    Internal implementation method.

    """
    return _libsbml.SBMLTransforms_evaluateASTNode(node, m)

def SBMLTransforms_expandL3V2InitialAssignments(m):
    """
    SBMLTransforms_expandL3V2InitialAssignments(Model m) -> bool


    Internal implementation method.

    """
    return _libsbml.SBMLTransforms_expandL3V2InitialAssignments(m)

def SBMLTransforms_mapComponentValues(m):
    """SBMLTransforms_mapComponentValues(Model m) -> IdList"""
    return _libsbml.SBMLTransforms_mapComponentValues(m)

def SBMLTransforms_clearComponentValues():
    """SBMLTransforms_clearComponentValues()"""
    return _libsbml.SBMLTransforms_clearComponentValues()

def SBMLTransforms_nodeContainsId(node, ids):
    """SBMLTransforms_nodeContainsId(ASTNode node, IdList ids) -> bool"""
    return _libsbml.SBMLTransforms_nodeContainsId(node, ids)

CNV_TYPE_BOOL = _libsbml.CNV_TYPE_BOOL
CNV_TYPE_DOUBLE = _libsbml.CNV_TYPE_DOUBLE
CNV_TYPE_INT = _libsbml.CNV_TYPE_INT
CNV_TYPE_SINGLE = _libsbml.CNV_TYPE_SINGLE
CNV_TYPE_STRING = _libsbml.CNV_TYPE_STRING
class ConversionOption(_object):
    """

    A single configuration setting for an SBML converter.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  It is a class used in the
    implementation of extra functionality provided by libSBML.

    LibSBML provides a number of converters that can perform
    transformations on SBML documents.  These converters allow their
    behaviors to be controlled by setting property values.  Converter
    properties are communicated using objects of class
    ConversionProperties, and within such objects, individual options are
    encapsulated using ConversionOption objects.

    A ConversionOption object consists of four parts:

    * A key, acting as the name of the option.

    * A value of this option.

    * A type for the value; the type code is chosen from a set of
    integer constants whose names all begin with the prefix CNV_TYPE_.
    (See the separate subsection below for more information.)

    * A description consisting of a text string that describes the
    option in some way.

    There are no constraints on the values of keys or descriptions;
    authors of SBML converters are free to choose them as they see fit.

    Conversion option data types
    ======================================================================

    An option in ConversionOption must have a data type declared, to
    indicate whether it is a string value, an integer, and so forth.  The
    possible types of values are taken from a set of constants whose
    symbol names begin with the prefix CNV_TYPE_. The following are the
    possible values:

    <p> <center>

       Enumerator       Meaning                                           
       CNV_TYPE_BOOL    Indicates the value type is a Boolean.            
       CNV_TYPE_DOUBLE  Indicates the value type is a double-sized float. 
       CNV_TYPE_INT     Indicates the value type is an integer.           
       CNV_TYPE_SINGLE  Indicates the value type is a float.              
       CNV_TYPE_STRING  Indicates the value type is a string.

    </center>

    See also ConversionProperties.

    """

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConversionOption, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ConversionOption, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ConversionOption self, string key, string value, ConversionOptionType_t type=CNV_TYPE_STRING, string description) -> ConversionOption
        __init__(ConversionOption self, string key, string value, ConversionOptionType_t type=CNV_TYPE_STRING) -> ConversionOption
        __init__(ConversionOption self, string key, string value) -> ConversionOption
        __init__(ConversionOption self, string key) -> ConversionOption
        __init__(ConversionOption self, string key, char const * value, string description) -> ConversionOption
        __init__(ConversionOption self, string key, char const * value) -> ConversionOption
        __init__(ConversionOption self, string key, bool value, string description) -> ConversionOption
        __init__(ConversionOption self, string key, bool value) -> ConversionOption
        __init__(ConversionOption self, string key, double value, string description) -> ConversionOption
        __init__(ConversionOption self, string key, double value) -> ConversionOption
        __init__(ConversionOption self, string key, float value, string description) -> ConversionOption
        __init__(ConversionOption self, string key, float value) -> ConversionOption
        __init__(ConversionOption self, string key, int value, string description) -> ConversionOption
        __init__(ConversionOption self, string key, int value) -> ConversionOption
        __init__(ConversionOption self, ConversionOption orig) -> ConversionOption


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ConversionOption(string key, bool value, string
        description='')

        Creates a new ConversionOption specialized for Boolean-type options.

        Parameter 'key' is the key for this option. Parameter 'value' is the
        value for this option. Parameter 'description' is an optional
        description.

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        ______________________________________________________________________
        Method variant with the following signature:

            ConversionOption(string key, string value='',
        ConversionOptionType_t type=CNV_TYPE_STRING, string description='')

        Creates a new ConversionOption.

        This is the general constructor, taking arguments for all aspects of
        an option.  Other constructors exist with different arguments.

        The conversion 'type' argument value must be one of the constants
        whose names begin with the characters CNV_TYPE_ in the interface class
        libsbml.

        Parameter 'key' is the key for this option. Parameter 'value' is an
        optional value for this option. Parameter 'type' is the type of this
        option. Parameter 'description' is the description for this option.

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        ______________________________________________________________________
        Method variant with the following signature:

            ConversionOption(string key, string value, string
        description='')

        Creates a new ConversionOption specialized for string-type options.

        Parameter 'key' is the key for this option. Parameter 'value' is the
        value for this option. Parameter 'description' is an optional
        description.

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        ______________________________________________________________________
        Method variant with the following signature:

            ConversionOption(string key, double value, string
        description='')

        Creates a new ConversionOption specialized for double-type options.

        Parameter 'key' is the key for this option. Parameter 'value' is the
        value for this option. Parameter 'description' is an optional
        description.

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        ______________________________________________________________________
        Method variant with the following signature:

            ConversionOption(string key, float value, string
        description='')

        Creates a new ConversionOption specialized for float-type options.

        Parameter 'key' is the key for this option. Parameter 'value' is the
        value for this option. Parameter 'description' is an optional
        description.

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        ______________________________________________________________________
        Method variant with the following signature:

            ConversionOption(string key, int value, string
        description='')

        Creates a new ConversionOption specialized for integer-type options.

        Parameter 'key' is the key for this option. Parameter 'value' is the
        value for this option. Parameter 'description' is an optional
        description.

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        ______________________________________________________________________
        Method variant with the following signature:

            ConversionOption(ConversionOption orig)

        Copy constructor; creates a copy of an ConversionOption object.

        Parameter 'orig' is the ConversionOption object to copy.

        """
        this = _libsbml.new_ConversionOption(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_ConversionOption
    __del__ = lambda self: None

    def clone(self):
        """
        clone(ConversionOption self) -> ConversionOption


        Creates and returns a deep copy of this ConversionOption object.

        Returns the (deep) copy of this ConversionOption object.

        """
        return _libsbml.ConversionOption_clone(self)


    def getKey(self):
        """
        getKey(ConversionOption self) -> string


        Returns the key for this option.

        Returns the key, as a string.

        """
        return _libsbml.ConversionOption_getKey(self)


    def setKey(self, key):
        """
        setKey(ConversionOption self, string key)


        Sets the key for this option.

        Parameter 'key' is a string representing the key to set.

        """
        return _libsbml.ConversionOption_setKey(self, key)


    def getValue(self):
        """
        getValue(ConversionOption self) -> string


        Returns the value of this option.

        Returns the value of this option, as a string.

        """
        return _libsbml.ConversionOption_getValue(self)


    def setValue(self, value):
        """
        setValue(ConversionOption self, string value)


        Sets the value for this option.

        Parameter 'value' is the value to set, as a string.

        """
        return _libsbml.ConversionOption_setValue(self, value)


    def getDescription(self):
        """
        getDescription(ConversionOption self) -> string


        Returns the description string for this option.

        Returns the description of this option.

        """
        return _libsbml.ConversionOption_getDescription(self)


    def setDescription(self, description):
        """
        setDescription(ConversionOption self, string description)


        Sets the description text for this option.

        Parameter 'description' is the description to set for this option.

        """
        return _libsbml.ConversionOption_setDescription(self, description)


    def getType(self):
        """
        getType(ConversionOption self) -> ConversionOptionType_t


        Returns the type of this option

        Returns the type of this option.

        """
        return _libsbml.ConversionOption_getType(self)


    def setType(self, type):
        """
        setType(ConversionOption self, ConversionOptionType_t type)


        Sets the type of this option.

        The conversion 'type' argument value must be one of the constants
        whose names begin with the characters CNV_TYPE_ in the interface class
        libsbml.

        Parameter 'type' is the type value to use.

        """
        return _libsbml.ConversionOption_setType(self, type)


    def getBoolValue(self):
        """
        getBoolValue(ConversionOption self) -> bool


        Returns the value of this option as a Boolean.

        Returns the value of this option.

        """
        return _libsbml.ConversionOption_getBoolValue(self)


    def setBoolValue(self, value):
        """
        setBoolValue(ConversionOption self, bool value)


        Set the value of this option to a given Boolean value.

        Invoking this method will also set the type of the option to
        CNV_TYPE_BOOL.

        Parameter 'value' is the Boolean value to set.

        """
        return _libsbml.ConversionOption_setBoolValue(self, value)


    def getDoubleValue(self):
        """
        getDoubleValue(ConversionOption self) -> double


        Returns the value of this option as a 'float.'

        Returns the value of this option.

        """
        return _libsbml.ConversionOption_getDoubleValue(self)


    def setDoubleValue(self, value):
        """
        setDoubleValue(ConversionOption self, double value)


        Set the value of this option to a given 'float' value.

        Invoking this method will also set the type of the option to
        CNV_TYPE_DOUBLE.

        Parameter 'value' is the value to set.

        """
        return _libsbml.ConversionOption_setDoubleValue(self, value)


    def getFloatValue(self):
        """
        getFloatValue(ConversionOption self) -> float


        Returns the value of this option as a 'float.'

        Returns the value of this option as a float.

        """
        return _libsbml.ConversionOption_getFloatValue(self)


    def setFloatValue(self, value):
        """
        setFloatValue(ConversionOption self, float value)


        Set the value of this option to a given 'float' value.

        Invoking this method will also set the type of the option to
        CNV_TYPE_SINGLE.

        Parameter 'value' is the value to set.

        """
        return _libsbml.ConversionOption_setFloatValue(self, value)


    def getIntValue(self):
        """
        getIntValue(ConversionOption self) -> int


        Returns the value of this option as an 'integer.'

        Returns the value of this option, as an int.

        """
        return _libsbml.ConversionOption_getIntValue(self)


    def setIntValue(self, value):
        """
        setIntValue(ConversionOption self, int value)


        Set the value of this option to a given 'int' value.

        Invoking this method will also set the type of the option to
        CNV_TYPE_INT.

        Parameter 'value' is the value to set.

        """
        return _libsbml.ConversionOption_setIntValue(self, value)

ConversionOption_swigregister = _libsbml.ConversionOption_swigregister
ConversionOption_swigregister(ConversionOption)

class ConversionProperties(_object):
    """

    Set of configuration option values for a converter.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  It is a class used in the
    implementation of extra functionality provided by libSBML.

    LibSBML provides a number of converters that can perform
    transformations on SBML documents. The properties of SBML converters
    are communicated using objects of class ConversionProperties, and
    within such objects, individual options are encapsulated using
    ConversionOption objects.  The ConversionProperties class provides
    numerous methods for setting and getting options.

    ConversionProperties objects are also used to determine the target
    SBML namespace when an SBML converter's behavior depends on the
    intended Level+Version combination of SBML.  In addition, it is
    conceivable that conversions may be affected by SBML Level 3 packages
    being used by an SBML document; consequently, the packages in use are
    also communicated by the values of the SBML namespaces set on a
    ConversionProperties object.

    General information about the use of SBML converters
    ======================================================================

    The use of all the converters follows a similar approach.  First, one
    creates a ConversionProperties object and calls
    ConversionProperties.addOption() on this object with one argument: a
    text string that identifies the desired converter.  (The text string
    is specific to each converter; consult the documentation for a given
    converter to find out how it should be enabled.)

    Next, for some converters, the caller can optionally set some
    converter-specific properties using additional calls to
    ConversionProperties.addOption(). Many converters provide the ability
    to configure their behavior to some extent; this is realized through
    the use of properties that offer different options.  The default
    property values for each converter can be interrogated using the
    method SBMLConverter.getDefaultProperties() on the converter class in
    question .

    Finally, the caller should invoke the method SBMLDocument.convert()
    with the ConversionProperties object as an argument.

    Example of invoking an SBML converter
    ......................................................................

    The following code fragment illustrates an example using
    SBMLReactionConverter, which is invoked using the option string
    ''replaceReactions':'

      config = ConversionProperties()
      if config != None:
        config.addOption('replaceReactions')

    In the case of SBMLReactionConverter, there are no options to affect
    its behavior, so the next step is simply to invoke the converter on an
    SBMLDocument object.  Continuing the example code:

        # Assume that the variable 'document' has been set to an SBMLDocument object.
        status = document.convert(config)
        if status != LIBSBML_OPERATION_SUCCESS:
          # Handle error somehow.
          print('Error: conversion failed due to the following:')
          document.printErrors()

    Here is an example of using a converter that offers an option. The
    following code invokes SBMLStripPackageConverter to remove the SBML
    Level 3 Layout package from a model.  It sets the name of the package
    to be removed by adding a value for the option named ''package''
    defined by that converter:

      def strip_layout_example(document):
        config = ConversionProperties()
        if config != None:
          config.addOption('stripPackage')
          config.addOption('package', 'layout')
          status = document.convert(config)
          if status != LIBSBML_OPERATION_SUCCESS:
            # Handle error somehow.
            print('Error: unable to strip the Layout package.')
            print('LibSBML returned error: ' + OperationReturnValue_toString(status).strip())
        else:
          # Handle error somehow.
          print('Error: unable to create ConversionProperties object')

    Available SBML converters in libSBML
    ......................................................................

    LibSBML provides a number of built-in converters; by convention, their
    names end in Converter. The following are the built-in converters
    provided by libSBML 5.18.0 :

    @copydetails doc_list_of_libsbml_converters

    See also ConversionOption, SBMLNamespaces.

    """

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConversionProperties, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ConversionProperties, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ConversionProperties self, SBMLNamespaces targetNS=None) -> ConversionProperties
        __init__(ConversionProperties self) -> ConversionProperties
        __init__(ConversionProperties self, ConversionProperties orig) -> ConversionProperties


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ConversionProperties(ConversionProperties orig)

        Copy constructor.

        Parameter 'orig' is the object to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            ConversionProperties(SBMLNamespaces targetNS=None)

        Constructor that initializes the conversion properties with a specific
        SBML target namespace.

        Parameter 'targetNS' is the target namespace to convert to.

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        """
        this = _libsbml.new_ConversionProperties(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ConversionProperties self) -> ConversionProperties


        Creates and returns a deep copy of this ConversionProperties object.

        Returns the (deep) copy of this ConversionProperties object.

        """
        return _libsbml.ConversionProperties_clone(self)

    __swig_destroy__ = _libsbml.delete_ConversionProperties
    __del__ = lambda self: None

    def getTargetNamespaces(self):
        """
        getTargetNamespaces(ConversionProperties self) -> SBMLNamespaces


        Returns the current target SBML namespace.

        Returns the SBMLNamepaces object expressing the target namespace.

        """
        return _libsbml.ConversionProperties_getTargetNamespaces(self)


    def hasTargetNamespaces(self):
        """
        hasTargetNamespaces(ConversionProperties self) -> bool


        Returns 'True' if the target SBML namespace has been set.

        Returns 'True' if the target namespace has been set, 'False'
        otherwise.

        """
        return _libsbml.ConversionProperties_hasTargetNamespaces(self)


    def setTargetNamespaces(self, targetNS):
        """
        setTargetNamespaces(ConversionProperties self, SBMLNamespaces targetNS)


        Sets the target namespace.

        Parameter 'targetNS' is the target namespace to use.

        """
        return _libsbml.ConversionProperties_setTargetNamespaces(self, targetNS)


    def getDescription(self, key):
        """
        getDescription(ConversionProperties self, string key) -> string


        Returns the description string for a given option in this properties
        object.

        Parameter 'key' is the key for the option.

        Returns the description text of the option with the given key.

        """
        return _libsbml.ConversionProperties_getDescription(self, key)


    def getType(self, key):
        """
        getType(ConversionProperties self, string key) -> ConversionOptionType_t


        Returns the type of a given option in this properties object.

        Parameter 'key' is the key for the option.

        Returns the type of the option with the given key.

        """
        return _libsbml.ConversionProperties_getType(self, key)


    def getOption(self, *args):
        """
        getOption(ConversionProperties self, string key) -> ConversionOption
        getOption(ConversionProperties self, int index) -> ConversionOption


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getOption(int index)

        Returns the ConversionOption object for the given 'index'.

        Parameter 'index' is the index for the option.

        Returns the option with the given 'index'.

        ______________________________________________________________________
        Method variant with the following signature:

            getOption(string key)

        Returns the ConversionOption object for a given key.

        Parameter 'key' is the key for the option.

        Returns the option with the given key.

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


    def addOption(self, *args):
        """
        addOption(ConversionProperties self, ConversionOption option)
        addOption(ConversionProperties self, string key, string value, ConversionOptionType_t type=CNV_TYPE_STRING, string description)
        addOption(ConversionProperties self, string key, string value, ConversionOptionType_t type=CNV_TYPE_STRING)
        addOption(ConversionProperties self, string key, string value)
        addOption(ConversionProperties self, string key)
        addOption(ConversionProperties self, string key, char const * value, string description)
        addOption(ConversionProperties self, string key, char const * value)
        addOption(ConversionProperties self, string key, bool value, string description)
        addOption(ConversionProperties self, string key, bool value)
        addOption(ConversionProperties self, string key, double value, string description)
        addOption(ConversionProperties self, string key, double value)
        addOption(ConversionProperties self, string key, float value, string description)
        addOption(ConversionProperties self, string key, float value)
        addOption(ConversionProperties self, string key, int value, string description)
        addOption(ConversionProperties self, string key, int value)


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            addOption(ConversionOption option)

        Adds a copy of the given option to this properties object.

        Parameter 'option' is the option to add.

        ______________________________________________________________________
        Method variant with the following signature:

            addOption(string key, double value, string description='')

        Adds a new ConversionOption object with the given parameters.

        Parameter 'key' is the key for the new option. Parameter 'value' is
        the double value of that option. Parameter 'description' is (optional)
        the description for the option.

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        ______________________________________________________________________
        Method variant with the following signature:

            addOption(string key, string value='', ConversionOptionType_t
        type=CNV_TYPE_STRING, string description='')

        Adds a new ConversionOption object with the given parameters.

        Parameter 'key' is the key for the new option. Parameter 'value' is
        (optional) the value of that option. Parameter 'type' is (optional)
        the type of the option (see the documentation for ConversionOption for
        more information about the types). Parameter 'description' is
        (optional) the description for the option.

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        ______________________________________________________________________
        Method variant with the following signature:

            addOption(string key, string value, string description='')

        Adds a new ConversionOption object with the given parameters.

        Parameter 'key' is the key for the new option. Parameter 'value' is
        the string value of that option. Parameter 'description' is (optional)
        the description for the option.

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        ______________________________________________________________________
        Method variant with the following signature:

            addOption(string key, bool value, string description='')

        Adds a new ConversionOption object with the given parameters.

        Parameter 'key' is the key for the new option. Parameter 'value' is
        the boolean value of that option. Parameter 'description' is
        (optional) the description for the option.

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        ______________________________________________________________________
        Method variant with the following signature:

            addOption(string key, float value, string description='')

        Adds a new ConversionOption object with the given parameters.

        Parameter 'key' is the key for the new option. Parameter 'value' is
        the float value of that option. Parameter 'description' is (optional)
        the description for the option.

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        ______________________________________________________________________
        Method variant with the following signature:

            addOption(string key, int value, string description='')

        Adds a new ConversionOption object with the given parameters.

        Parameter 'key' is the key for the new option. Parameter 'value' is
        the integer value of that option. Parameter 'description' is
        (optional) the description for the option.

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

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


    def removeOption(self, key):
        """
        removeOption(ConversionProperties self, string key) -> ConversionOption


        Removes the option with the given key from this properties object.

        Parameter 'key' is the key for the new option to remove. Returns the
        removed option.

        """
        return _libsbml.ConversionProperties_removeOption(self, key)


    def hasOption(self, key):
        """
        hasOption(ConversionProperties self, string key) -> bool


        Returns 'True' if this properties object contains an option with the
        given key.

        Parameter 'key' is the key of the option to find.

        Returns 'True' if an option with the given 'key' exists in this
        properties object, 'False' otherwise.

        """
        return _libsbml.ConversionProperties_hasOption(self, key)


    def getValue(self, key):
        """
        getValue(ConversionProperties self, string key) -> string


        Returns the value of the given option as a string.

        Parameter 'key' is the key for the option.

        Returns the string value of the option with the given key.

        """
        return _libsbml.ConversionProperties_getValue(self, key)


    def setValue(self, key, value):
        """
        setValue(ConversionProperties self, string key, string value)


        Sets the value of the given option to a string.

        Parameter 'key' is the key for the option. Parameter 'value' is the
        new value.

        """
        return _libsbml.ConversionProperties_setValue(self, key, value)


    def getBoolValue(self, key):
        """
        getBoolValue(ConversionProperties self, string key) -> bool


        Returns the value of the given option as a Boolean.

        Parameter 'key' is the key for the option.

        Returns the boolean value of the option with the given key.

        """
        return _libsbml.ConversionProperties_getBoolValue(self, key)


    def setBoolValue(self, key, value):
        """
        setBoolValue(ConversionProperties self, string key, bool value)


        Sets the value of the given option to a Boolean.

        Parameter 'key' is the key for the option.

        Parameter 'value' is the new Boolean value.

        """
        return _libsbml.ConversionProperties_setBoolValue(self, key, value)


    def getDoubleValue(self, key):
        """
        getDoubleValue(ConversionProperties self, string key) -> double


        Returns the value of the given option as a 'float.'

        Parameter 'key' is the key for the option.

        Returns the double value of the option with the given key.

        """
        return _libsbml.ConversionProperties_getDoubleValue(self, key)


    def setDoubleValue(self, key, value):
        """
        setDoubleValue(ConversionProperties self, string key, double value)


        Sets the value of the given option to a 'float.'

        Parameter 'key' is the key for the option.

        Parameter 'value' is the new double value.

        """
        return _libsbml.ConversionProperties_setDoubleValue(self, key, value)


    def getFloatValue(self, key):
        """
        getFloatValue(ConversionProperties self, string key) -> float


        Returns the value of the given option as a 'float.'

        Parameter 'key' is the key for the option.

        Returns the float value of the option with the given key.

        """
        return _libsbml.ConversionProperties_getFloatValue(self, key)


    def setFloatValue(self, key, value):
        """
        setFloatValue(ConversionProperties self, string key, float value)


        Sets the value of the given option to a 'float.'

        Parameter 'key' is the key for the option.

        Parameter 'value' is the new float value.

        """
        return _libsbml.ConversionProperties_setFloatValue(self, key, value)


    def getIntValue(self, key):
        """
        getIntValue(ConversionProperties self, string key) -> int


        Returns the value of the given option as an integer.

        Parameter 'key' is the key for the option.

        Returns the int value of the option with the given key.

        """
        return _libsbml.ConversionProperties_getIntValue(self, key)


    def setIntValue(self, key, value):
        """
        setIntValue(ConversionProperties self, string key, int value)


        Sets the value of the given option to an integer.

        Parameter 'key' is the key for the option.

        Parameter 'value' is the new integer value.

        """
        return _libsbml.ConversionProperties_setIntValue(self, key, value)


    def getNumOptions(self):
        """
        getNumOptions(ConversionProperties self) -> int


        Returns the number of options in this Conversion Properties object

        Returns the number of options in this properties object.

        """
        return _libsbml.ConversionProperties_getNumOptions(self)

ConversionProperties_swigregister = _libsbml.ConversionProperties_swigregister
ConversionProperties_swigregister(ConversionProperties)

class SBMLConverter(_object):
    """

    Base class for SBML converters.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  It is a class used in the
    implementation of extra functionality provided by libSBML.

    The SBMLConverter class is the base class for the various SBML
    converters: classes of objects that transform or convert SBML
    documents. These transformations can involve essentially anything that
    can be written algorithmically; examples include converting the units
    of measurement in a model, or converting from one Level+Version
    combination of SBML to another.  Applications can also create their
    own converters by subclassing SBMLConverter and following the examples
    of the existing converters.

    General information about the use of SBML converters
    ======================================================================

    The use of all the converters follows a similar approach.  First, one
    creates a ConversionProperties object and calls
    ConversionProperties.addOption() on this object with one argument: a
    text string that identifies the desired converter.  (The text string
    is specific to each converter; consult the documentation for a given
    converter to find out how it should be enabled.)

    Next, for some converters, the caller can optionally set some
    converter-specific properties using additional calls to
    ConversionProperties.addOption(). Many converters provide the ability
    to configure their behavior to some extent; this is realized through
    the use of properties that offer different options.  The default
    property values for each converter can be interrogated using the
    method SBMLConverter.getDefaultProperties() on the converter class in
    question .

    Finally, the caller should invoke the method SBMLDocument.convert()
    with the ConversionProperties object as an argument.

    Example of invoking an SBML converter
    ......................................................................

    The following code fragment illustrates an example using
    SBMLReactionConverter, which is invoked using the option string
    ''replaceReactions':'

      config = ConversionProperties()
      if config != None:
        config.addOption('replaceReactions')

    In the case of SBMLReactionConverter, there are no options to affect
    its behavior, so the next step is simply to invoke the converter on an
    SBMLDocument object.  Continuing the example code:

        # Assume that the variable 'document' has been set to an SBMLDocument object.
        status = document.convert(config)
        if status != LIBSBML_OPERATION_SUCCESS:
          # Handle error somehow.
          print('Error: conversion failed due to the following:')
          document.printErrors()

    Here is an example of using a converter that offers an option. The
    following code invokes SBMLStripPackageConverter to remove the SBML
    Level 3 Layout package from a model.  It sets the name of the package
    to be removed by adding a value for the option named ''package''
    defined by that converter:

      def strip_layout_example(document):
        config = ConversionProperties()
        if config != None:
          config.addOption('stripPackage')
          config.addOption('package', 'layout')
          status = document.convert(config)
          if status != LIBSBML_OPERATION_SUCCESS:
            # Handle error somehow.
            print('Error: unable to strip the Layout package.')
            print('LibSBML returned error: ' + OperationReturnValue_toString(status).strip())
        else:
          # Handle error somehow.
          print('Error: unable to create ConversionProperties object')

    Available SBML converters in libSBML
    ......................................................................

    LibSBML provides a number of built-in converters; by convention, their
    names end in Converter. The following are the built-in converters
    provided by libSBML 5.18.0 :

    @copydetails doc_list_of_libsbml_converters

    """

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLConverter, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SBMLConverter, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(SBMLConverter self) -> SBMLConverter
        __init__(SBMLConverter self, string name) -> SBMLConverter
        __init__(SBMLConverter self, SBMLConverter orig) -> SBMLConverter


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            SBMLConverter()

        Creates a new SBMLConverter object.

        ______________________________________________________________________
        Method variant with the following signature:

            SBMLConverter(SBMLConverter orig)

        Copy constructor.

        This creates a copy of an SBMLConverter object.

        Parameter 'orig' is the SBMLConverter object to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            SBMLConverter(string name)

        Creates a new SBMLConverter object with a given name.

        Parameter 'name' is the name for the converter to create.

        """
        if self.__class__ == SBMLConverter:
            _self = None
        else:
            _self = self
        this = _libsbml.new_SBMLConverter(_self, *args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_SBMLConverter
    __del__ = lambda self: None

    def clone(self):
        """
        clone(SBMLConverter self) -> SBMLConverter


        Creates and returns a deep copy of this SBMLConverter object.

        Returns the (deep) copy of this SBMLConverter object.

        """
        return _libsbml.SBMLConverter_clone(self)


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


        Returns the SBML document that is the subject of the conversions.

        Returns the current SBMLDocument object.

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


    def getDefaultProperties(self):
        """
        getDefaultProperties(SBMLConverter self) -> ConversionProperties


        Returns the default properties of this converter.

        A given converter exposes one or more properties that can be adjusted
        in order to influence the behavior of the converter.  This method
        returns the default property settings for this converter.  It is meant
        to be called in order to discover all the settings for the converter
        object.  The run-time properties of the converter object can be
        adjusted by using the method SBMLConverter.setProperties().

        Returns the default properties for the converter.

        See also setProperties(), matchesProperties().

        """
        return _libsbml.SBMLConverter_getDefaultProperties(self)


    def getTargetNamespaces(self):
        """
        getTargetNamespaces(SBMLConverter self) -> SBMLNamespaces


        Returns the target SBML namespaces of the currently set properties.

        SBML namespaces are used by libSBML to express the Level+Version of
        the SBML document (and, possibly, any SBML Level 3 packages in use).
        Some converters' behavior is affected by the SBML namespace configured
        in the converter.  For example, in SBMLLevelVersionConverter (the
        converter for converting SBML documents from one Level+Version
        combination to another), the actions are fundamentally dependent on
        the SBML namespaces targeted.

        Returns the SBMLNamespaces object that describes the SBML namespaces
        in effect, or 'None' if none are set.

        """
        return _libsbml.SBMLConverter_getTargetNamespaces(self)


    def matchesProperties(self, props):
        """
        matchesProperties(SBMLConverter self, ConversionProperties props) -> bool


        Returns 'True' if this converter matches the given properties.

        Given a ConversionProperties object 'props', this method checks that
        'props' possesses an option value to enable this converter.  If it
        does, this method returns 'True.'

        Parameter 'props' is the properties to match.

        Returns 'True' if the properties 'props' would match the necessary
        properties for this type of converter, 'False' otherwise.

        """
        return _libsbml.SBMLConverter_matchesProperties(self, props)


    def setDocument(self, doc):
        """
        setDocument(SBMLConverter self, SBMLDocument doc) -> int


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            setDocument(SBMLDocument doc)

        Sets the SBML document to be converted.

        Parameter 'doc' is the document to use for this conversion.

        Returns integer value indicating the success/failure of the operation.
        The set of possible values that may be returned ultimately depends on
        the specific subclass of SBMLConverter being used, but the default
        method can return the following:

        * LIBSBML_OPERATION_SUCCESS

        ______________________________________________________________________
        Method variant with the following signature:

            setDocument(SBMLDocument doc)

        Sets the SBML document to be converted.

        Parameter 'doc' is the document to use for this conversion.

        Returns integer value indicating the success/failure of the operation.
        The set of possible values that may be returned ultimately depends on
        the specific subclass of SBMLConverter being used, but the default
        method can return the following:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.SBMLConverter_setDocument(self, doc)


    def setProperties(self, props):
        """
        setProperties(SBMLConverter self, ConversionProperties props) -> int


        Sets the configuration properties to be used by this converter.

        Parameter 'props' is the ConversionProperties object defining the
        properties to set.

        Returns integer value indicating the success/failure of the operation.
        The set of possible values that may be returned ultimately depends on
        the specific subclass of SBMLConverter being used, but the default
        method can return the following values:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getProperties(), matchesProperties().

        """
        return _libsbml.SBMLConverter_setProperties(self, props)


    def getProperties(self):
        """
        getProperties(SBMLConverter self) -> ConversionProperties


        Returns the current properties in effect for this converter.

        A given converter exposes one or more properties that can be adjusted
        in order to influence the behavior of the converter.  This method
        returns the current properties for this converter; in other words, the
        settings in effect at this moment.  To change the property values, you
        can use SBMLConverter.setProperties().

        Returns the currently set configuration properties.

        See also setProperties(), matchesProperties().

        """
        return _libsbml.SBMLConverter_getProperties(self)


    def convert(self):
        """
        convert(SBMLConverter self) -> int


        Perform the conversion.

        This method causes the converter to do the actual conversion work,
        that is, to convert the SBMLDocument object set by
        SBMLConverter.setDocument() and with the configuration options set by
        SBMLConverter.setProperties().

        Returns integer value indicating the success/failure of the operation.
        The set of possible values that may be returned depends on the
        converter subclass; please consult the documentation for the relevant
        class to find out what the possibilities are.

        """
        return _libsbml.SBMLConverter_convert(self)


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


        Returns the name of this converter.

        Returns a string, the name of this converter.

        """
        return _libsbml.SBMLConverter_getName(self)

    def __disown__(self):
        self.this.disown()
        _libsbml.disown_SBMLConverter(self)
        return weakref_proxy(self)
SBMLConverter_swigregister = _libsbml.SBMLConverter_swigregister
SBMLConverter_swigregister(SBMLConverter)

class SBMLConverterRegistry(_object):
    """

    Registry of all libSBML SBML converters.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  It is a class used in the
    implementation of extra functionality provided by libSBML.

    LibSBML provides facilities for transforming and converting SBML
    documents in various ways.  These transformations can involve
    essentially anything that can be written algorithmically; examples
    include converting the units of measurement in a model, or converting
    from one Level+Version combination of SBML to another.  Converters are
    implemented as objects derived from the class SBMLConverter.

    The converter registry, implemented as a singleton object of class
    SBMLConverterRegistry, maintains a list of known converters and
    provides methods for discovering them.  Callers can use the method
    SBMLConverterRegistry.getNumConverters() to find out how many
    converters are registered, then use
    SBMLConverterRegistry.getConverterByIndex() to iterate over each one;
    alternatively, callers can use SBMLConverterRegistry.getConverterFor()
    to search for a converter having specific properties.

    """

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLConverterRegistry, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SBMLConverterRegistry, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def getInstance():
        """
        getInstance() -> SBMLConverterRegistry


        Returns the singleton instance for the converter registry.

        Prior to using the registry, callers have to obtain a copy of the
        registry.  This static method provides the means for doing that.

        Returns the singleton for the converter registry.

        """
        return _libsbml.SBMLConverterRegistry_getInstance()

    getInstance = staticmethod(getInstance)

    def addConverter(self, converter):
        """
        addConverter(SBMLConverterRegistry self, SBMLConverter converter) -> int


        Adds the given converter to the registry of SBML converters.

        Parameter 'converter' is the converter to add to the registry.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_OBJECT

        """
        return _libsbml.SBMLConverterRegistry_addConverter(self, converter)


    def getConverterByIndex(self, index):
        """
        getConverterByIndex(SBMLConverterRegistry self, int index) -> SBMLConverter


        Returns the converter with the given index number.

        Converters are given arbitrary index numbers by the registry.  Callers
        can use the method SBMLConverterRegistry.getNumConverters() to find
        out how many converters are registered, then use this method to
        iterate over the list and obtain each one in turn.

        Parameter 'index' is the zero-based index of the converter to fetch.

        Returns the converter with the given index number, or 'None' if the
        number is less than '0' or there is no converter at the given index
        position.

        """
        return _libsbml.SBMLConverterRegistry_getConverterByIndex(self, index)


    def getConverterFor(self, props):
        """
        getConverterFor(SBMLConverterRegistry self, ConversionProperties props) -> SBMLConverter


        Returns the converter that best matches the given configuration
        properties.

        Many converters provide the ability to configure their behavior.  This
        is realized through the use of properties that offer different
        options.  The present method allows callers to search for converters
        that have specific property values.  Callers can do this by creating a
        ConversionProperties object, adding the desired option(s) to the
        object, then passing the object to this method.

        Parameter 'props' is a ConversionProperties object defining the
        properties to match against.

        Returns the converter matching the properties, or 'None' if no
        suitable converter is found.

        See also getConverterByIndex().

        """
        return _libsbml.SBMLConverterRegistry_getConverterFor(self, props)


    def getNumConverters(self):
        """
        getNumConverters(SBMLConverterRegistry self) -> int


        Returns the number of converters known by the registry.

        Returns the number of registered converters.

        See also getConverterByIndex().

        """
        return _libsbml.SBMLConverterRegistry_getNumConverters(self)

    __swig_destroy__ = _libsbml.delete_SBMLConverterRegistry
    __del__ = lambda self: None
SBMLConverterRegistry_swigregister = _libsbml.SBMLConverterRegistry_swigregister
SBMLConverterRegistry_swigregister(SBMLConverterRegistry)

def SBMLConverterRegistry_getInstance():
    """
    SBMLConverterRegistry_getInstance() -> SBMLConverterRegistry


    Returns the singleton instance for the converter registry.

    Prior to using the registry, callers have to obtain a copy of the
    registry.  This static method provides the means for doing that.

    Returns the singleton for the converter registry.

    """
    return _libsbml.SBMLConverterRegistry_getInstance()

class SBMLFunctionDefinitionConverter(SBMLConverter):
    """

    Converter to expand user-defined functions in-line.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  It is a class used in the
    implementation of extra functionality provided by libSBML.

    This converter manipulates user-defined functions in an SBML file.
    When invoked on a model, it performs the following operations:

    * Reads the list of user-defined functions in the model (i.e., the
    list of FunctionDefinition objects);

    * Looks for invocations of the function in mathematical expressions
    throughout the model; and

    * For each invocation found, replaces the invocation with a in-line
    copy of the function's body, similar to how macro expansions might be
    performed in scripting and programming languages.

    For example, suppose the model contains a function definition
    representing the function f(x, y) = x * y.  Further suppose this
    functions invoked somewhere else in the model, in a mathematical
    formula, as f(s, p).  The outcome of running
    SBMLFunctionDefinitionConverter on the model will be to replace the
    call to f with the expression s * p.

    Configuration and use of SBMLFunctionDefinitionConverter
    ======================================================================

    SBMLFunctionDefinitionConverter is enabled by creating a
    ConversionProperties object with the option
    ''expandFunctionDefinitions',' and passing this properties object to
    SBMLDocument.convert(). The converter accepts one option:

    * ''skipIds':' if set, it should be a string containing a comma-
    separated list of identifiers (SBML 'id' values) that are to be
    skipped during function conversion.  Functions whose identifiers are
    found in this list will not be converted.

    General information about the use of SBML converters
    ======================================================================

    The use of all the converters follows a similar approach.  First, one
    creates a ConversionProperties object and calls
    ConversionProperties.addOption() on this object with one argument: a
    text string that identifies the desired converter.  (The text string
    is specific to each converter; consult the documentation for a given
    converter to find out how it should be enabled.)

    Next, for some converters, the caller can optionally set some
    converter-specific properties using additional calls to
    ConversionProperties.addOption(). Many converters provide the ability
    to configure their behavior to some extent; this is realized through
    the use of properties that offer different options.  The default
    property values for each converter can be interrogated using the
    method SBMLConverter.getDefaultProperties() on the converter class in
    question .

    Finally, the caller should invoke the method SBMLDocument.convert()
    with the ConversionProperties object as an argument.

    Example of invoking an SBML converter
    ......................................................................

    The following code fragment illustrates an example using
    SBMLReactionConverter, which is invoked using the option string
    ''replaceReactions':'

      config = ConversionProperties()
      if config != None:
        config.addOption('replaceReactions')

    In the case of SBMLReactionConverter, there are no options to affect
    its behavior, so the next step is simply to invoke the converter on an
    SBMLDocument object.  Continuing the example code:

        # Assume that the variable 'document' has been set to an SBMLDocument object.
        status = document.convert(config)
        if status != LIBSBML_OPERATION_SUCCESS:
          # Handle error somehow.
          print('Error: conversion failed due to the following:')
          document.printErrors()

    Here is an example of using a converter that offers an option. The
    following code invokes SBMLStripPackageConverter to remove the SBML
    Level 3 Layout package from a model.  It sets the name of the package
    to be removed by adding a value for the option named ''package''
    defined by that converter:

      def strip_layout_example(document):
        config = ConversionProperties()
        if config != None:
          config.addOption('stripPackage')
          config.addOption('package', 'layout')
          status = document.convert(config)
          if status != LIBSBML_OPERATION_SUCCESS:
            # Handle error somehow.
            print('Error: unable to strip the Layout package.')
            print('LibSBML returned error: ' + OperationReturnValue_toString(status).strip())
        else:
          # Handle error somehow.
          print('Error: unable to create ConversionProperties object')

    Available SBML converters in libSBML
    ......................................................................

    LibSBML provides a number of built-in converters; by convention, their
    names end in Converter. The following are the built-in converters
    provided by libSBML 5.18.0 :

    @copydetails doc_list_of_libsbml_converters

    """

    __swig_setmethods__ = {}
    for _s in [SBMLConverter]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLFunctionDefinitionConverter, name, value)
    __swig_getmethods__ = {}
    for _s in [SBMLConverter]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SBMLFunctionDefinitionConverter, name)
    __repr__ = _swig_repr

    def init():
        """
        init()


        Internal implementation method.

        """
        return _libsbml.SBMLFunctionDefinitionConverter_init()

    init = staticmethod(init)

    def __init__(self, *args):
        """
        __init__(SBMLFunctionDefinitionConverter self) -> SBMLFunctionDefinitionConverter
        __init__(SBMLFunctionDefinitionConverter self, SBMLFunctionDefinitionConverter obj) -> SBMLFunctionDefinitionConverter


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            SBMLFunctionDefinitionConverter()

        Creates a new SBMLFunctionDefinitionConverter object.

        ______________________________________________________________________
        Method variant with the following signature:

            SBMLFunctionDefinitionConverter(SBMLFunctionDefinitionConvert
        er obj)

        Copy constructor; creates a copy of an SBMLFunctionDefinitionConverter
        object.

        Parameter 'obj' is the SBMLFunctionDefinitionConverter object to copy.

        """
        this = _libsbml.new_SBMLFunctionDefinitionConverter(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(SBMLFunctionDefinitionConverter self) -> SBMLFunctionDefinitionConverter


        Creates and returns a deep copy of this
        SBMLFunctionDefinitionConverter object.

        Returns a (deep) copy of this converter.

        """
        return _libsbml.SBMLFunctionDefinitionConverter_clone(self)

    __swig_destroy__ = _libsbml.delete_SBMLFunctionDefinitionConverter
    __del__ = lambda self: None

    def matchesProperties(self, props):
        """
        matchesProperties(SBMLFunctionDefinitionConverter self, ConversionProperties props) -> bool


        Returns 'True' if this converter object's properties match the given
        properties.

        A typical use of this method involves creating a ConversionProperties
        object, setting the options desired, and then calling this method on
        an SBMLFunctionDefinitionConverter object to find out if the object's
        property values match the given ones.  This method is also used by
        SBMLConverterRegistry.getConverterFor() to search across all
        registered converters for one matching particular properties.

        Parameter 'props' is the properties to match.

        Returns 'True' if this converter's properties match, 'False'
        otherwise.

        """
        return _libsbml.SBMLFunctionDefinitionConverter_matchesProperties(self, props)


    def convert(self):
        """
        convert(SBMLFunctionDefinitionConverter self) -> int


        Perform the conversion.

        This method causes the converter to do the actual conversion work,
        that is, to convert the SBMLDocument object set by
        SBMLConverter.setDocument() and with the configuration options set by
        SBMLConverter.setProperties().

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_CONV_INVALID_SRC_DOCUMENT

        """
        return _libsbml.SBMLFunctionDefinitionConverter_convert(self)


    def getDefaultProperties(self):
        """
        getDefaultProperties(SBMLFunctionDefinitionConverter self) -> ConversionProperties


        Returns the default properties of this converter.

        A given converter exposes one or more properties that can be adjusted
        in order to influence the behavior of the converter.  This method
        returns the default property settings for this converter.  It is meant
        to be called in order to discover all the settings for the converter
        object.

        Returns the ConversionProperties object describing the default
        properties for this converter.

        """
        return _libsbml.SBMLFunctionDefinitionConverter_getDefaultProperties(self)

SBMLFunctionDefinitionConverter_swigregister = _libsbml.SBMLFunctionDefinitionConverter_swigregister
SBMLFunctionDefinitionConverter_swigregister(SBMLFunctionDefinitionConverter)

def SBMLFunctionDefinitionConverter_init():
    """
    SBMLFunctionDefinitionConverter_init()


    Internal implementation method.

    """
    return _libsbml.SBMLFunctionDefinitionConverter_init()

class SBMLIdConverter(SBMLConverter):
    """

    Converter for replacing object identifiers.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  It is a class used in the
    implementation of extra functionality provided by libSBML.

    This converter translates all instances of a given identifier (i.e.,
    SBML object 'id' attribute value) of type 'SId' in a Model to another
    identifier.  It does this based on a list of source identifiers,
    translating each one to its corresponding replacement value in a list
    of replacement identifiers.  It also updates all references to the
    identifiers so replaced.  (More technically, it replaces all values
    known as type 'SIdRef' in the SBML Level 3 specifications.)

    This converter only searches the global SId namespace for the Model
    child of the  SBMLDocument.  It does not replace any IDs or SIdRefs
    for LocalParameters, nor does it replace any UnitSIds or UnitSIdRefs.
    It likewise does not replace any IDs in a new namespace introduced by
    a package, such as the PortSId namespace from the Hierarchical Model
    Composition package, nor any Model objects that are not the direct
    child of the SBMLDocument, such as the ModelDefinitions from  the
    Hierarchical Model Composition package.

    If, however, a package introduces a new element with an 'id' attribute
    of type SId, any attribute of type SIdRef, or child of type SIdRef
    (such as  a new Math child of a package element), those IDs will be
    replaced if they match a source identifier.

    Configuration and use of SBMLIdConverter
    ======================================================================

    SBMLIdConverter is enabled by creating a ConversionProperties object
    with the option ''renameSIds',' and passing this properties object to
    SBMLDocument.convert(). The converter accepts two options, and both
    must be set or else no conversion is performed:

    * ''currentIds':' A comma-separated list of identifiers to
    replace.

    * ''newIds':' A comma-separated list of identifiers to use as the
    replacements.  The values should correspond one-to-one with the
    identifiers in ''currentIds'' that should be replaced.

    General information about the use of SBML converters
    ======================================================================

    The use of all the converters follows a similar approach.  First, one
    creates a ConversionProperties object and calls
    ConversionProperties.addOption() on this object with one argument: a
    text string that identifies the desired converter.  (The text string
    is specific to each converter; consult the documentation for a given
    converter to find out how it should be enabled.)

    Next, for some converters, the caller can optionally set some
    converter-specific properties using additional calls to
    ConversionProperties.addOption(). Many converters provide the ability
    to configure their behavior to some extent; this is realized through
    the use of properties that offer different options.  The default
    property values for each converter can be interrogated using the
    method SBMLConverter.getDefaultProperties() on the converter class in
    question .

    Finally, the caller should invoke the method SBMLDocument.convert()
    with the ConversionProperties object as an argument.

    Example of invoking an SBML converter
    ......................................................................

    The following code fragment illustrates an example using
    SBMLReactionConverter, which is invoked using the option string
    ''replaceReactions':'

      config = ConversionProperties()
      if config != None:
        config.addOption('replaceReactions')

    In the case of SBMLReactionConverter, there are no options to affect
    its behavior, so the next step is simply to invoke the converter on an
    SBMLDocument object.  Continuing the example code:

        # Assume that the variable 'document' has been set to an SBMLDocument object.
        status = document.convert(config)
        if status != LIBSBML_OPERATION_SUCCESS:
          # Handle error somehow.
          print('Error: conversion failed due to the following:')
          document.printErrors()

    Here is an example of using a converter that offers an option. The
    following code invokes SBMLStripPackageConverter to remove the SBML
    Level 3 Layout package from a model.  It sets the name of the package
    to be removed by adding a value for the option named ''package''
    defined by that converter:

      def strip_layout_example(document):
        config = ConversionProperties()
        if config != None:
          config.addOption('stripPackage')
          config.addOption('package', 'layout')
          status = document.convert(config)
          if status != LIBSBML_OPERATION_SUCCESS:
            # Handle error somehow.
            print('Error: unable to strip the Layout package.')
            print('LibSBML returned error: ' + OperationReturnValue_toString(status).strip())
        else:
          # Handle error somehow.
          print('Error: unable to create ConversionProperties object')

    Available SBML converters in libSBML
    ......................................................................

    LibSBML provides a number of built-in converters; by convention, their
    names end in Converter. The following are the built-in converters
    provided by libSBML 5.18.0 :

    @copydetails doc_list_of_libsbml_converters

    """

    __swig_setmethods__ = {}
    for _s in [SBMLConverter]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLIdConverter, name, value)
    __swig_getmethods__ = {}
    for _s in [SBMLConverter]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SBMLIdConverter, name)
    __repr__ = _swig_repr

    def init():
        """
        init()


        Internal implementation method.

        """
        return _libsbml.SBMLIdConverter_init()

    init = staticmethod(init)

    def __init__(self, *args):
        """
        __init__(SBMLIdConverter self) -> SBMLIdConverter
        __init__(SBMLIdConverter self, SBMLIdConverter obj) -> SBMLIdConverter


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            SBMLIdConverter(SBMLIdConverter obj)

        Copy constructor; creates a copy of an SBMLIdConverter object.

        Parameter 'obj' is the SBMLIdConverter object to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            SBMLIdConverter()

        Creates a new SBMLIdConverter object.

        """
        this = _libsbml.new_SBMLIdConverter(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(SBMLIdConverter self) -> SBMLIdConverter


        Creates and returns a deep copy of this SBMLIdConverter object.

        Returns a (deep) copy of this converter.

        """
        return _libsbml.SBMLIdConverter_clone(self)

    __swig_destroy__ = _libsbml.delete_SBMLIdConverter
    __del__ = lambda self: None

    def matchesProperties(self, props):
        """
        matchesProperties(SBMLIdConverter self, ConversionProperties props) -> bool


        Returns 'True' if this converter object's properties match the given
        properties.

        A typical use of this method involves creating a ConversionProperties
        object, setting the options desired, and then calling this method on
        an SBMLIdConverter object to find out if the object's property values
        match the given ones.  This method is also used by
        SBMLConverterRegistry.getConverterFor() to search across all
        registered converters for one matching particular properties.

        Parameter 'props' is the properties to match.

        Returns 'True' if this converter's properties match, 'False'
        otherwise.

        """
        return _libsbml.SBMLIdConverter_matchesProperties(self, props)


    def convert(self):
        """
        convert(SBMLIdConverter self) -> int


        Perform the conversion.

        This method causes the converter to do the actual conversion work,
        that is, to convert the SBMLDocument object set by
        SBMLConverter.setDocument() and with the configuration options set by
        SBMLConverter.setProperties().

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.SBMLIdConverter_convert(self)


    def getDefaultProperties(self):
        """
        getDefaultProperties(SBMLIdConverter self) -> ConversionProperties


        Returns the default properties of this converter.

        A given converter exposes one or more properties that can be adjusted
        in order to influence the behavior of the converter.  This method
        returns the default property settings for this converter.  It is meant
        to be called in order to discover all the settings for the converter
        object.

        Returns the ConversionProperties object describing the default
        properties for this converter.

        """
        return _libsbml.SBMLIdConverter_getDefaultProperties(self)

SBMLIdConverter_swigregister = _libsbml.SBMLIdConverter_swigregister
SBMLIdConverter_swigregister(SBMLIdConverter)

def SBMLIdConverter_init():
    """
    SBMLIdConverter_init()


    Internal implementation method.

    """
    return _libsbml.SBMLIdConverter_init()

class SBMLInferUnitsConverter(SBMLConverter):
    """

    Converter for inferring and setting parameter units.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  It is a class used in the
    implementation of extra functionality provided by libSBML.

    This SBML converter takes an SBML document and attempts to infer
    units for any Parameter objects whose units are undeclared.  It then
    sets the 'units' attribute of those parameters to the units inferred
    (if necessary, creating new UnitDefinition objects on the model in the
    process).

    Configuration and use of SBMLInferUnitsConverter
    ======================================================================

    SBMLInferUnitsConverter is enabled by creating a ConversionProperties
    object with the option ''inferUnits',' and passing this properties
    object to SBMLDocument.convert(). The converter offers no other
    options.

    General information about the use of SBML converters
    ======================================================================

    The use of all the converters follows a similar approach.  First, one
    creates a ConversionProperties object and calls
    ConversionProperties.addOption() on this object with one argument: a
    text string that identifies the desired converter.  (The text string
    is specific to each converter; consult the documentation for a given
    converter to find out how it should be enabled.)

    Next, for some converters, the caller can optionally set some
    converter-specific properties using additional calls to
    ConversionProperties.addOption(). Many converters provide the ability
    to configure their behavior to some extent; this is realized through
    the use of properties that offer different options.  The default
    property values for each converter can be interrogated using the
    method SBMLConverter.getDefaultProperties() on the converter class in
    question .

    Finally, the caller should invoke the method SBMLDocument.convert()
    with the ConversionProperties object as an argument.

    Example of invoking an SBML converter
    ......................................................................

    The following code fragment illustrates an example using
    SBMLReactionConverter, which is invoked using the option string
    ''replaceReactions':'

      config = ConversionProperties()
      if config != None:
        config.addOption('replaceReactions')

    In the case of SBMLReactionConverter, there are no options to affect
    its behavior, so the next step is simply to invoke the converter on an
    SBMLDocument object.  Continuing the example code:

        # Assume that the variable 'document' has been set to an SBMLDocument object.
        status = document.convert(config)
        if status != LIBSBML_OPERATION_SUCCESS:
          # Handle error somehow.
          print('Error: conversion failed due to the following:')
          document.printErrors()

    Here is an example of using a converter that offers an option. The
    following code invokes SBMLStripPackageConverter to remove the SBML
    Level 3 Layout package from a model.  It sets the name of the package
    to be removed by adding a value for the option named ''package''
    defined by that converter:

      def strip_layout_example(document):
        config = ConversionProperties()
        if config != None:
          config.addOption('stripPackage')
          config.addOption('package', 'layout')
          status = document.convert(config)
          if status != LIBSBML_OPERATION_SUCCESS:
            # Handle error somehow.
            print('Error: unable to strip the Layout package.')
            print('LibSBML returned error: ' + OperationReturnValue_toString(status).strip())
        else:
          # Handle error somehow.
          print('Error: unable to create ConversionProperties object')

    Available SBML converters in libSBML
    ......................................................................

    LibSBML provides a number of built-in converters; by convention, their
    names end in Converter. The following are the built-in converters
    provided by libSBML 5.18.0 :

    @copydetails doc_list_of_libsbml_converters

    """

    __swig_setmethods__ = {}
    for _s in [SBMLConverter]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLInferUnitsConverter, name, value)
    __swig_getmethods__ = {}
    for _s in [SBMLConverter]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SBMLInferUnitsConverter, name)
    __repr__ = _swig_repr

    def init():
        """
        init()


        Internal implementation method.

        """
        return _libsbml.SBMLInferUnitsConverter_init()

    init = staticmethod(init)

    def __init__(self, *args):
        """
        __init__(SBMLInferUnitsConverter self) -> SBMLInferUnitsConverter
        __init__(SBMLInferUnitsConverter self, SBMLInferUnitsConverter obj) -> SBMLInferUnitsConverter


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            SBMLInferUnitsConverter()

        Creates a new SBMLInferUnitsConverter object.

        ______________________________________________________________________
        Method variant with the following signature:

            SBMLInferUnitsConverter(SBMLInferUnitsConverter obj)

        Copy constructor; creates a copy of an SBMLInferUnitsConverter object.

        Parameter 'obj' is the SBMLInferUnitsConverter object to copy.

        """
        this = _libsbml.new_SBMLInferUnitsConverter(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_SBMLInferUnitsConverter
    __del__ = lambda self: None

    def clone(self):
        """
        clone(SBMLInferUnitsConverter self) -> SBMLInferUnitsConverter


        Creates and returns a deep copy of this SBMLInferUnitsConverter
        object.

        Returns a (deep) copy of this converter.

        """
        return _libsbml.SBMLInferUnitsConverter_clone(self)


    def matchesProperties(self, props):
        """
        matchesProperties(SBMLInferUnitsConverter self, ConversionProperties props) -> bool


        Returns 'True' if this converter object's properties match the given
        properties.

        A typical use of this method involves creating a ConversionProperties
        object, setting the options desired, and then calling this method on
        an SBMLInferUnitsConverter object to find out if the object's property
        values match the given ones.  This method is also used by
        SBMLConverterRegistry.getConverterFor() to search across all
        registered converters for one matching particular properties.

        Parameter 'props' is the properties to match.

        Returns 'True' if this converter's properties match, 'False'
        otherwise.

        """
        return _libsbml.SBMLInferUnitsConverter_matchesProperties(self, props)


    def convert(self):
        """
        convert(SBMLInferUnitsConverter self) -> int


        Perform the conversion.

        This method causes the converter to do the actual conversion work,
        that is, to convert the SBMLDocument object set by
        SBMLConverter.setDocument() and with the configuration options set by
        SBMLConverter.setProperties().

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_CONV_INVALID_SRC_DOCUMENT

        """
        return _libsbml.SBMLInferUnitsConverter_convert(self)


    def getDefaultProperties(self):
        """
        getDefaultProperties(SBMLInferUnitsConverter self) -> ConversionProperties


        Returns the default properties of this converter.

        A given converter exposes one or more properties that can be adjusted
        in order to influence the behavior of the converter.  This method
        returns the default property settings for this converter.  It is meant
        to be called in order to discover all the settings for the converter
        object.

        Returns the ConversionProperties object describing the default
        properties for this converter.

        """
        return _libsbml.SBMLInferUnitsConverter_getDefaultProperties(self)

SBMLInferUnitsConverter_swigregister = _libsbml.SBMLInferUnitsConverter_swigregister
SBMLInferUnitsConverter_swigregister(SBMLInferUnitsConverter)

def SBMLInferUnitsConverter_init():
    """
    SBMLInferUnitsConverter_init()


    Internal implementation method.

    """
    return _libsbml.SBMLInferUnitsConverter_init()

class SBMLInitialAssignmentConverter(SBMLConverter):
    """

    Converter that removes SBML initial assignments.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  It is a class used in the
    implementation of extra functionality provided by libSBML.

    This is an SBML converter for replacing InitialAssignment objects,
    when possible, by setting the initial value attributes on the model
    objects being assigned.  In other words, for every object that is the
    target of an initial assignment in the model, the converter evaluates
    the mathematical expression of the assignment to get a numerical
    value, and then sets the corresponding attribute of the object to the
    value.  The effects for different kinds of SBML components are as
    follows:

    <center>

      +------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------+
      | Component        | Effect                                                                                                                                                             |
      +------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------+
      | Compartment      | Sets the value of the size attribute.                                                                                                                              |
      | Species          | Sets the value of either the initialAmount or the initialConcentration attributes, depending on the value of the Species object's hasOnlySubstanceUnits attribute. |
      | Parameter        | Sets the value of the value attribute.                                                                                                                             |
      | SpeciesReference | Sets the value of the stoichiometry attribute in the Reaction object where the SpeciesReference object appears.                                                    |
      +------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------+

    </center>

    Configuration and use of SBMLInitialAssignmentConverter
    ======================================================================

    SBMLInitialAssignmentConverter is enabled by creating a
    ConversionProperties object with the option
    ''expandInitialAssignments',' and passing this properties object to
    SBMLDocument.convert().  The converter offers no other options.

    General information about the use of SBML converters
    ======================================================================

    The use of all the converters follows a similar approach.  First, one
    creates a ConversionProperties object and calls
    ConversionProperties.addOption() on this object with one argument: a
    text string that identifies the desired converter.  (The text string
    is specific to each converter; consult the documentation for a given
    converter to find out how it should be enabled.)

    Next, for some converters, the caller can optionally set some
    converter-specific properties using additional calls to
    ConversionProperties.addOption(). Many converters provide the ability
    to configure their behavior to some extent; this is realized through
    the use of properties that offer different options.  The default
    property values for each converter can be interrogated using the
    method SBMLConverter.getDefaultProperties() on the converter class in
    question .

    Finally, the caller should invoke the method SBMLDocument.convert()
    with the ConversionProperties object as an argument.

    Example of invoking an SBML converter
    ......................................................................

    The following code fragment illustrates an example using
    SBMLReactionConverter, which is invoked using the option string
    ''replaceReactions':'

      config = ConversionProperties()
      if config != None:
        config.addOption('replaceReactions')

    In the case of SBMLReactionConverter, there are no options to affect
    its behavior, so the next step is simply to invoke the converter on an
    SBMLDocument object.  Continuing the example code:

        # Assume that the variable 'document' has been set to an SBMLDocument object.
        status = document.convert(config)
        if status != LIBSBML_OPERATION_SUCCESS:
          # Handle error somehow.
          print('Error: conversion failed due to the following:')
          document.printErrors()

    Here is an example of using a converter that offers an option. The
    following code invokes SBMLStripPackageConverter to remove the SBML
    Level 3 Layout package from a model.  It sets the name of the package
    to be removed by adding a value for the option named ''package''
    defined by that converter:

      def strip_layout_example(document):
        config = ConversionProperties()
        if config != None:
          config.addOption('stripPackage')
          config.addOption('package', 'layout')
          status = document.convert(config)
          if status != LIBSBML_OPERATION_SUCCESS:
            # Handle error somehow.
            print('Error: unable to strip the Layout package.')
            print('LibSBML returned error: ' + OperationReturnValue_toString(status).strip())
        else:
          # Handle error somehow.
          print('Error: unable to create ConversionProperties object')

    Available SBML converters in libSBML
    ......................................................................

    LibSBML provides a number of built-in converters; by convention, their
    names end in Converter. The following are the built-in converters
    provided by libSBML 5.18.0 :

    @copydetails doc_list_of_libsbml_converters

    """

    __swig_setmethods__ = {}
    for _s in [SBMLConverter]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLInitialAssignmentConverter, name, value)
    __swig_getmethods__ = {}
    for _s in [SBMLConverter]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SBMLInitialAssignmentConverter, name)
    __repr__ = _swig_repr

    def init():
        """
        init()


        Internal implementation method.

        """
        return _libsbml.SBMLInitialAssignmentConverter_init()

    init = staticmethod(init)

    def __init__(self, *args):
        """
        __init__(SBMLInitialAssignmentConverter self) -> SBMLInitialAssignmentConverter
        __init__(SBMLInitialAssignmentConverter self, SBMLInitialAssignmentConverter obj) -> SBMLInitialAssignmentConverter


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            SBMLInitialAssignmentConverter(SBMLInitialAssignmentConverter
        obj)

        Copy constructor; creates a copy of an SBMLInitialAssignmentConverter
        object.

        Parameter 'obj' is the SBMLInitialAssignmentConverter object to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            SBMLInitialAssignmentConverter()

        Creates a new SBMLInitialAssignmentConverter object.

        """
        this = _libsbml.new_SBMLInitialAssignmentConverter(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(SBMLInitialAssignmentConverter self) -> SBMLInitialAssignmentConverter


        Creates and returns a deep copy of this SBMLInitialAssignmentConverter
        object.

        Returns a (deep) copy of this converter.

        """
        return _libsbml.SBMLInitialAssignmentConverter_clone(self)

    __swig_destroy__ = _libsbml.delete_SBMLInitialAssignmentConverter
    __del__ = lambda self: None

    def matchesProperties(self, props):
        """
        matchesProperties(SBMLInitialAssignmentConverter self, ConversionProperties props) -> bool


        Returns 'True' if this converter object's properties match the given
        properties.

        A typical use of this method involves creating a ConversionProperties
        object, setting the options desired, and then calling this method on
        an SBMLInitialAssignmentConverter object to find out if the object's
        property values match the given ones.  This method is also used by
        SBMLConverterRegistry.getConverterFor() to search across all
        registered converters for one matching particular properties.

        Parameter 'props' is the properties to match.

        Returns 'True' if this converter's properties match, 'False'
        otherwise.

        """
        return _libsbml.SBMLInitialAssignmentConverter_matchesProperties(self, props)


    def convert(self):
        """
        convert(SBMLInitialAssignmentConverter self) -> int


        Perform the conversion.

        This method causes the converter to do the actual conversion work,
        that is, to convert the SBMLDocument object set by
        SBMLConverter.setDocument() and with the configuration options set by
        SBMLConverter.setProperties().

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        """
        return _libsbml.SBMLInitialAssignmentConverter_convert(self)


    def getDefaultProperties(self):
        """
        getDefaultProperties(SBMLInitialAssignmentConverter self) -> ConversionProperties


        Returns the default properties of this converter.

        A given converter exposes one or more properties that can be adjusted
        in order to influence the behavior of the converter.  This method
        returns the default property settings for this converter.  It is meant
        to be called in order to discover all the settings for the converter
        object.

        Returns the ConversionProperties object describing the default
        properties for this converter.

        """
        return _libsbml.SBMLInitialAssignmentConverter_getDefaultProperties(self)

SBMLInitialAssignmentConverter_swigregister = _libsbml.SBMLInitialAssignmentConverter_swigregister
SBMLInitialAssignmentConverter_swigregister(SBMLInitialAssignmentConverter)

def SBMLInitialAssignmentConverter_init():
    """
    SBMLInitialAssignmentConverter_init()


    Internal implementation method.

    """
    return _libsbml.SBMLInitialAssignmentConverter_init()

class SBMLLevelVersionConverter(SBMLConverter):
    """

    Whole-document SBML Level/Version converter.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  It is a class used in the
    implementation of extra functionality provided by libSBML.

    This SBML converter takes an SBML document having one SBML
    Level+Version combination, and attempts to convert it to an SBML
    document having a different Level+Version combination.

    This class is also the basis for SBMLDocument.setLevelAndVersion().

    Configuration and use of SBMLLevelVersionConverter
    ======================================================================

    SBMLLevelVersionConverter is enabled by creating a
    ConversionProperties object with the option ''setLevelAndVersion','
    and passing this properties object to SBMLDocument.convert().  The
    target SBML Level and Version combination are determined by the value
    of the SBML namespace set on the ConversionProperties object (using
    ConversionProperties.setTargetNamespaces()).

    In addition, this converter offers the following options:

    * ''strict':' If this option has the value 'True,' then the
    validity of the SBML document will be strictly preserved.  This means
    that SBML validation will be performed, and if the original model is
    not valid or semantics cannot be preserved in the converted model,
    then conversion will not be performed.  Conversely, if this option is
    set to 'False,' model conversion will always be performed; if any
    errors are detected related to altered semantics, the errors will be
    logged in the usual way (i.e., the error log on the SBMLDocument
    object).

    * ''addDefaultUnits':' By default, a conversion from SBML Level 2
    to Level 3 will explicitly add UnitDefinition objects and unit
    attributes on the Model object to define units that are implicitly
    defined in SBML Level 2.  This is usually desirable because in SBML
    Level 3, there are no default units and a conversion from Level 2 that
    did not add unit definitions would actually result in a loss of
    information.  However, some users or software tools may not need or
    want this, or worse, may be fooled into thinking that libSBML has
    somehow inferred the proper units for model quantities.  (It has not;
    it merely adds generic predefined units.)  This option lets callers
    control this behavior.

    General information about the use of SBML converters
    ======================================================================

    The use of all the converters follows a similar approach.  First, one
    creates a ConversionProperties object and calls
    ConversionProperties.addOption() on this object with one argument: a
    text string that identifies the desired converter.  (The text string
    is specific to each converter; consult the documentation for a given
    converter to find out how it should be enabled.)

    Next, for some converters, the caller can optionally set some
    converter-specific properties using additional calls to
    ConversionProperties.addOption(). Many converters provide the ability
    to configure their behavior to some extent; this is realized through
    the use of properties that offer different options.  The default
    property values for each converter can be interrogated using the
    method SBMLConverter.getDefaultProperties() on the converter class in
    question .

    Finally, the caller should invoke the method SBMLDocument.convert()
    with the ConversionProperties object as an argument.

    Example of invoking an SBML converter
    ......................................................................

    The following code fragment illustrates an example using
    SBMLReactionConverter, which is invoked using the option string
    ''replaceReactions':'

      config = ConversionProperties()
      if config != None:
        config.addOption('replaceReactions')

    In the case of SBMLReactionConverter, there are no options to affect
    its behavior, so the next step is simply to invoke the converter on an
    SBMLDocument object.  Continuing the example code:

        # Assume that the variable 'document' has been set to an SBMLDocument object.
        status = document.convert(config)
        if status != LIBSBML_OPERATION_SUCCESS:
          # Handle error somehow.
          print('Error: conversion failed due to the following:')
          document.printErrors()

    Here is an example of using a converter that offers an option. The
    following code invokes SBMLStripPackageConverter to remove the SBML
    Level 3 Layout package from a model.  It sets the name of the package
    to be removed by adding a value for the option named ''package''
    defined by that converter:

      def strip_layout_example(document):
        config = ConversionProperties()
        if config != None:
          config.addOption('stripPackage')
          config.addOption('package', 'layout')
          status = document.convert(config)
          if status != LIBSBML_OPERATION_SUCCESS:
            # Handle error somehow.
            print('Error: unable to strip the Layout package.')
            print('LibSBML returned error: ' + OperationReturnValue_toString(status).strip())
        else:
          # Handle error somehow.
          print('Error: unable to create ConversionProperties object')

    Available SBML converters in libSBML
    ......................................................................

    LibSBML provides a number of built-in converters; by convention, their
    names end in Converter. The following are the built-in converters
    provided by libSBML 5.18.0 :

    @copydetails doc_list_of_libsbml_converters

    """

    __swig_setmethods__ = {}
    for _s in [SBMLConverter]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLLevelVersionConverter, name, value)
    __swig_getmethods__ = {}
    for _s in [SBMLConverter]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SBMLLevelVersionConverter, name)
    __repr__ = _swig_repr

    def init():
        """
        init()


        Internal implementation method.

        """
        return _libsbml.SBMLLevelVersionConverter_init()

    init = staticmethod(init)

    def __init__(self, *args):
        """
        __init__(SBMLLevelVersionConverter self) -> SBMLLevelVersionConverter
        __init__(SBMLLevelVersionConverter self, SBMLLevelVersionConverter obj) -> SBMLLevelVersionConverter


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            SBMLLevelVersionConverter()

        Creates a new SBMLLevelVersionConverter object.

        ______________________________________________________________________
        Method variant with the following signature:

            SBMLLevelVersionConverter(SBMLLevelVersionConverter obj)

        Copy constructor; creates a copy of an SBMLLevelVersionConverter
        object.

        Parameter 'obj' is the SBMLLevelVersionConverter object to copy.

        """
        this = _libsbml.new_SBMLLevelVersionConverter(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_SBMLLevelVersionConverter
    __del__ = lambda self: None

    def clone(self):
        """
        clone(SBMLLevelVersionConverter self) -> SBMLLevelVersionConverter


        Creates and returns a deep copy of this SBMLLevelVersionConverter
        object.

        Returns a (deep) copy of this converter.

        """
        return _libsbml.SBMLLevelVersionConverter_clone(self)


    def matchesProperties(self, props):
        """
        matchesProperties(SBMLLevelVersionConverter self, ConversionProperties props) -> bool


        Returns 'True' if this converter object's properties match the given
        properties.

        A typical use of this method involves creating a ConversionProperties
        object, setting the options desired, and then calling this method on
        an SBMLLevelVersionConverter object to find out if the object's
        property values match the given ones.  This method is also used by
        SBMLConverterRegistry.getConverterFor() to search across all
        registered converters for one matching particular properties.

        Parameter 'props' is the properties to match.

        Returns 'True' if this converter's properties match, 'False'
        otherwise.

        """
        return _libsbml.SBMLLevelVersionConverter_matchesProperties(self, props)


    def convert(self):
        """
        convert(SBMLLevelVersionConverter self) -> int


        Perform the conversion.

        This method causes the converter to do the actual conversion work,
        that is, to convert the SBMLDocument object set by
        SBMLConverter.setDocument() and with the configuration options set by
        SBMLConverter.setProperties().

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_CONV_INVALID_TARGET_NAMESPACE

        * LIBSBML_CONV_PKG_CONVERSION_NOT_AVAILABLE

        * LIBSBML_CONV_INVALID_SRC_DOCUMENT

        """
        return _libsbml.SBMLLevelVersionConverter_convert(self)


    def getDefaultProperties(self):
        """
        getDefaultProperties(SBMLLevelVersionConverter self) -> ConversionProperties


        Returns the default properties of this converter.

        A given converter exposes one or more properties that can be adjusted
        in order to influence the behavior of the converter.  This method
        returns the default property settings for this converter.  It is meant
        to be called in order to discover all the settings for the converter
        object.

        Returns the ConversionProperties object describing the default
        properties for this converter.

        """
        return _libsbml.SBMLLevelVersionConverter_getDefaultProperties(self)


    def getTargetLevel(self):
        """
        getTargetLevel(SBMLLevelVersionConverter self) -> unsigned int


        Returns the target SBML Level for the conversion.

        Returns an integer indicating the SBML Level.

        """
        return _libsbml.SBMLLevelVersionConverter_getTargetLevel(self)


    def getTargetVersion(self):
        """
        getTargetVersion(SBMLLevelVersionConverter self) -> unsigned int


        Returns the target SBML Version for the conversion.

        Returns an integer indicating the Version within the SBML Level.

        """
        return _libsbml.SBMLLevelVersionConverter_getTargetVersion(self)


    def getValidityFlag(self):
        """
        getValidityFlag(SBMLLevelVersionConverter self) -> bool


        Returns the flag indicating whether the conversion has been set to
        'strict'.

        Returns 'True' if strict validity has been requested, 'False'
        otherwise.

        """
        return _libsbml.SBMLLevelVersionConverter_getValidityFlag(self)


    def getAddDefaultUnits(self):
        """
        getAddDefaultUnits(SBMLLevelVersionConverter self) -> bool


        Returns the flag indicating whether default units should be added when
        converting to L3 or not.

        Returns 'True' if default units should be added, 'False' otherwise.

        """
        return _libsbml.SBMLLevelVersionConverter_getAddDefaultUnits(self)

SBMLLevelVersionConverter_swigregister = _libsbml.SBMLLevelVersionConverter_swigregister
SBMLLevelVersionConverter_swigregister(SBMLLevelVersionConverter)

def SBMLLevelVersionConverter_init():
    """
    SBMLLevelVersionConverter_init()


    Internal implementation method.

    """
    return _libsbml.SBMLLevelVersionConverter_init()

class SBMLLevel1Version1Converter(SBMLConverter):
    """

    Whole-document SBML Level/Version converter.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  It is a class used in the
    implementation of extra functionality provided by libSBML.

    This SBML converter takes an SBML document having one SBML
    Level+Version combination, and attempts to convert it to an SBML
    document having a different Level+Version combination.  This converter
    (SBMLLevel1Version1Converter) converts models to SBML Level 1 Version
    1, to the extent possible by the limited features of that
    Level/Version combination of SBML.

    Configuration and use of SBMLLevel1Version1Converter
    ======================================================================

    SBMLLevel1Version1Converter is enabled by creating a
    ConversionProperties object with the option ''convertToL1V1',' and
    passing this properties object to SBMLDocument.convert().  The target
    SBML Level and Version combination are determined by the value of the
    SBML namespace set on the ConversionProperties object (using
    ConversionProperties.setTargetNamespaces()).

    In addition, this converter offers the following options:

    * ''changePow':' Mathematical expressions for exponentiation of
    the form pow(s1, 2) will be converted to the expression s1^2.

    * ''inlineCompartmentSizes':' Back in the days of SBML Level 1
    Version 1, many software tools assumed that the 'kinetic laws' of SBML
    were written in terms of units of concentration/time.  These tools
    would not expect (and thus not handle) rate expressions such as
    CompartmentOfS1 * k * S1. When the option ''inlineCompartmentSizes''
    is enabled, libSBML will replace the references to compartments (such
    as ''CompartmentOfS1'' in this example) with their initial sizes.
    This is not strictly correct in all cases; in particular, if the
    compartment volume varies during simulation, this conversion will not
    reflect the expected behavior. However, many models do not have time-
    varying compartment sizes, so this option makes it easy to get modern
    SBML rate expressions into a form that old software tools may better
    understand.

    General information about the use of SBML converters
    ======================================================================

    The use of all the converters follows a similar approach.  First, one
    creates a ConversionProperties object and calls
    ConversionProperties.addOption() on this object with one argument: a
    text string that identifies the desired converter.  (The text string
    is specific to each converter; consult the documentation for a given
    converter to find out how it should be enabled.)

    Next, for some converters, the caller can optionally set some
    converter-specific properties using additional calls to
    ConversionProperties.addOption(). Many converters provide the ability
    to configure their behavior to some extent; this is realized through
    the use of properties that offer different options.  The default
    property values for each converter can be interrogated using the
    method SBMLConverter.getDefaultProperties() on the converter class in
    question .

    Finally, the caller should invoke the method SBMLDocument.convert()
    with the ConversionProperties object as an argument.

    Example of invoking an SBML converter
    ......................................................................

    The following code fragment illustrates an example using
    SBMLReactionConverter, which is invoked using the option string
    ''replaceReactions':'

      config = ConversionProperties()
      if config != None:
        config.addOption('replaceReactions')

    In the case of SBMLReactionConverter, there are no options to affect
    its behavior, so the next step is simply to invoke the converter on an
    SBMLDocument object.  Continuing the example code:

        # Assume that the variable 'document' has been set to an SBMLDocument object.
        status = document.convert(config)
        if status != LIBSBML_OPERATION_SUCCESS:
          # Handle error somehow.
          print('Error: conversion failed due to the following:')
          document.printErrors()

    Here is an example of using a converter that offers an option. The
    following code invokes SBMLStripPackageConverter to remove the SBML
    Level 3 Layout package from a model.  It sets the name of the package
    to be removed by adding a value for the option named ''package''
    defined by that converter:

      def strip_layout_example(document):
        config = ConversionProperties()
        if config != None:
          config.addOption('stripPackage')
          config.addOption('package', 'layout')
          status = document.convert(config)
          if status != LIBSBML_OPERATION_SUCCESS:
            # Handle error somehow.
            print('Error: unable to strip the Layout package.')
            print('LibSBML returned error: ' + OperationReturnValue_toString(status).strip())
        else:
          # Handle error somehow.
          print('Error: unable to create ConversionProperties object')

    Available SBML converters in libSBML
    ......................................................................

    LibSBML provides a number of built-in converters; by convention, their
    names end in Converter. The following are the built-in converters
    provided by libSBML 5.18.0 :

    @copydetails doc_list_of_libsbml_converters

    """

    __swig_setmethods__ = {}
    for _s in [SBMLConverter]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLLevel1Version1Converter, name, value)
    __swig_getmethods__ = {}
    for _s in [SBMLConverter]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SBMLLevel1Version1Converter, name)
    __repr__ = _swig_repr

    def init():
        """
        init()


        Internal implementation method.

        """
        return _libsbml.SBMLLevel1Version1Converter_init()

    init = staticmethod(init)

    def __init__(self, *args):
        """
        __init__(SBMLLevel1Version1Converter self) -> SBMLLevel1Version1Converter
        __init__(SBMLLevel1Version1Converter self, SBMLLevel1Version1Converter obj) -> SBMLLevel1Version1Converter


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            SBMLLevel1Version1Converter()

        Creates a new SBMLLevel1Version1Converter object.

        ______________________________________________________________________
        Method variant with the following signature:

            SBMLLevel1Version1Converter(SBMLLevel1Version1Converter obj)

        Copy constructor; creates a copy of an SBMLLevel1Version1Converter
        object.

        Parameter 'obj' is the SBMLLevel1Version1Converter object to copy.

        """
        this = _libsbml.new_SBMLLevel1Version1Converter(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_SBMLLevel1Version1Converter
    __del__ = lambda self: None

    def clone(self):
        """
        clone(SBMLLevel1Version1Converter self) -> SBMLLevel1Version1Converter


        Creates and returns a deep copy of this SBMLLevel1Version1Converter
        object.

        Returns a (deep) copy of this converter.

        """
        return _libsbml.SBMLLevel1Version1Converter_clone(self)


    def matchesProperties(self, props):
        """
        matchesProperties(SBMLLevel1Version1Converter self, ConversionProperties props) -> bool


        Returns 'True' if this converter object's properties match the given
        properties.

        A typical use of this method involves creating a ConversionProperties
        object, setting the options desired, and then calling this method on
        an SBMLLevel1Version1Converter object to find out if the object's
        property values match the given ones.  This method is also used by
        SBMLConverterRegistry.getConverterFor() to search across all
        registered converters for one matching particular properties.

        Parameter 'props' is the properties to match.

        Returns 'True' if this converter's properties match, 'False'
        otherwise.

        """
        return _libsbml.SBMLLevel1Version1Converter_matchesProperties(self, props)


    def convert(self):
        """
        convert(SBMLLevel1Version1Converter self) -> int


        Perform the conversion.

        This method causes the converter to do the actual conversion work,
        that is, to convert the SBMLDocument object set by
        SBMLConverter.setDocument() and with the configuration options set by
        SBMLConverter.setProperties().

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_CONV_INVALID_TARGET_NAMESPACE

        * LIBSBML_CONV_PKG_CONVERSION_NOT_AVAILABLE

        * LIBSBML_CONV_INVALID_SRC_DOCUMENT

        """
        return _libsbml.SBMLLevel1Version1Converter_convert(self)


    def getDefaultProperties(self):
        """
        getDefaultProperties(SBMLLevel1Version1Converter self) -> ConversionProperties


        Returns the default properties of this converter.

        A given converter exposes one or more properties that can be adjusted
        in order to influence the behavior of the converter.  This method
        returns the default property settings for this converter.  It is meant
        to be called in order to discover all the settings for the converter
        object.

        Returns the ConversionProperties object describing the default
        properties for this converter.

        """
        return _libsbml.SBMLLevel1Version1Converter_getDefaultProperties(self)

SBMLLevel1Version1Converter_swigregister = _libsbml.SBMLLevel1Version1Converter_swigregister
SBMLLevel1Version1Converter_swigregister(SBMLLevel1Version1Converter)

def SBMLLevel1Version1Converter_init():
    """
    SBMLLevel1Version1Converter_init()


    Internal implementation method.

    """
    return _libsbml.SBMLLevel1Version1Converter_init()

class SBMLLocalParameterConverter(SBMLConverter):
    """

    Converter to turn local parameters into global ones.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  It is a class used in the
    implementation of extra functionality provided by libSBML.

    This converter essentially promotes local parameters to global
    parameters. It works by examining every Reaction object for
    LocalParameter objects, then creating Parameter objects on the model
    for each one found, and finally removing the original LocalParameter
    objects.  It creates new identifiers for the fresh Parameter objects
    by concatenating the identifier of the reaction with the identifier of
    the original LocalParameter object.

    This converter can be useful for software applications that do not
    have the ability to handle local parameters on reactions.  Such
    applications could check incoming models for local parameters and run
    those models through this converter before proceeding with other
    steps.

    Configuration and use of SBMLLocalParameterConverter
    ======================================================================

    SBMLLocalParameterConverter is enabled by creating a
    ConversionProperties object with the option
    ''promoteLocalParameters',' and passing this properties object to
    SBMLDocument.convert().  The converter offers no other options.

    General information about the use of SBML converters
    ======================================================================

    The use of all the converters follows a similar approach.  First, one
    creates a ConversionProperties object and calls
    ConversionProperties.addOption() on this object with one argument: a
    text string that identifies the desired converter.  (The text string
    is specific to each converter; consult the documentation for a given
    converter to find out how it should be enabled.)

    Next, for some converters, the caller can optionally set some
    converter-specific properties using additional calls to
    ConversionProperties.addOption(). Many converters provide the ability
    to configure their behavior to some extent; this is realized through
    the use of properties that offer different options.  The default
    property values for each converter can be interrogated using the
    method SBMLConverter.getDefaultProperties() on the converter class in
    question .

    Finally, the caller should invoke the method SBMLDocument.convert()
    with the ConversionProperties object as an argument.

    Example of invoking an SBML converter
    ......................................................................

    The following code fragment illustrates an example using
    SBMLReactionConverter, which is invoked using the option string
    ''replaceReactions':'

      config = ConversionProperties()
      if config != None:
        config.addOption('replaceReactions')

    In the case of SBMLReactionConverter, there are no options to affect
    its behavior, so the next step is simply to invoke the converter on an
    SBMLDocument object.  Continuing the example code:

        # Assume that the variable 'document' has been set to an SBMLDocument object.
        status = document.convert(config)
        if status != LIBSBML_OPERATION_SUCCESS:
          # Handle error somehow.
          print('Error: conversion failed due to the following:')
          document.printErrors()

    Here is an example of using a converter that offers an option. The
    following code invokes SBMLStripPackageConverter to remove the SBML
    Level 3 Layout package from a model.  It sets the name of the package
    to be removed by adding a value for the option named ''package''
    defined by that converter:

      def strip_layout_example(document):
        config = ConversionProperties()
        if config != None:
          config.addOption('stripPackage')
          config.addOption('package', 'layout')
          status = document.convert(config)
          if status != LIBSBML_OPERATION_SUCCESS:
            # Handle error somehow.
            print('Error: unable to strip the Layout package.')
            print('LibSBML returned error: ' + OperationReturnValue_toString(status).strip())
        else:
          # Handle error somehow.
          print('Error: unable to create ConversionProperties object')

    Available SBML converters in libSBML
    ......................................................................

    LibSBML provides a number of built-in converters; by convention, their
    names end in Converter. The following are the built-in converters
    provided by libSBML 5.18.0 :

    @copydetails doc_list_of_libsbml_converters

    """

    __swig_setmethods__ = {}
    for _s in [SBMLConverter]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLLocalParameterConverter, name, value)
    __swig_getmethods__ = {}
    for _s in [SBMLConverter]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SBMLLocalParameterConverter, name)
    __repr__ = _swig_repr

    def init():
        """
        init()


        Internal implementation method.

        """
        return _libsbml.SBMLLocalParameterConverter_init()

    init = staticmethod(init)

    def __init__(self, *args):
        """
        __init__(SBMLLocalParameterConverter self) -> SBMLLocalParameterConverter
        __init__(SBMLLocalParameterConverter self, SBMLLocalParameterConverter obj) -> SBMLLocalParameterConverter


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            SBMLLocalParameterConverter(SBMLLocalParameterConverter obj)

        Copy constructor; creates a copy of an SBMLLocalParameterConverter
        object.

        Parameter 'obj' is the SBMLLocalParameterConverter object to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            SBMLLocalParameterConverter()

        Creates a new SBMLLocalParameterConverter object.

        """
        this = _libsbml.new_SBMLLocalParameterConverter(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(SBMLLocalParameterConverter self) -> SBMLLocalParameterConverter


        Creates and returns a deep copy of this SBMLLocalParameterConverter
        object.

        Returns a (deep) copy of this converter.

        """
        return _libsbml.SBMLLocalParameterConverter_clone(self)

    __swig_destroy__ = _libsbml.delete_SBMLLocalParameterConverter
    __del__ = lambda self: None

    def matchesProperties(self, props):
        """
        matchesProperties(SBMLLocalParameterConverter self, ConversionProperties props) -> bool


        Returns 'True' if this converter object's properties match the given
        properties.

        A typical use of this method involves creating a ConversionProperties
        object, setting the options desired, and then calling this method on
        an SBMLLocalParameterConverter object to find out if the object's
        property values match the given ones.  This method is also used by
        SBMLConverterRegistry.getConverterFor() to search across all
        registered converters for one matching particular properties.

        Parameter 'props' is the properties to match.

        Returns 'True' if this converter's properties match, 'False'
        otherwise.

        """
        return _libsbml.SBMLLocalParameterConverter_matchesProperties(self, props)


    def convert(self):
        """
        convert(SBMLLocalParameterConverter self) -> int


        Perform the conversion.

        This method causes the converter to do the actual conversion work,
        that is, to convert the SBMLDocument object set by
        SBMLConverter.setDocument() and with the configuration options set by
        SBMLConverter.setProperties().

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        """
        return _libsbml.SBMLLocalParameterConverter_convert(self)


    def getDefaultProperties(self):
        """
        getDefaultProperties(SBMLLocalParameterConverter self) -> ConversionProperties


        Returns the default properties of this converter.

        A given converter exposes one or more properties that can be adjusted
        in order to influence the behavior of the converter.  This method
        returns the default property settings for this converter.  It is meant
        to be called in order to discover all the settings for the converter
        object.

        Returns the ConversionProperties object describing the default
        properties for this converter.

        """
        return _libsbml.SBMLLocalParameterConverter_getDefaultProperties(self)

SBMLLocalParameterConverter_swigregister = _libsbml.SBMLLocalParameterConverter_swigregister
SBMLLocalParameterConverter_swigregister(SBMLLocalParameterConverter)

def SBMLLocalParameterConverter_init():
    """
    SBMLLocalParameterConverter_init()


    Internal implementation method.

    """
    return _libsbml.SBMLLocalParameterConverter_init()

class SBMLReactionConverter(SBMLConverter):
    """

    Converter to replace reactions with SBML rate rules.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  It is a class used in the
    implementation of extra functionality provided by libSBML.

    This converter will take an SBML model and replace the definitions of
    reactions in the model with definitions of SBML rate rules.
    Equivalent RateRule objects are only created for species mentioned in
    reactions that have KineticLaw subobjects, since those are the only
    reactions that have an effect on the rates of change of species in the
    model; however, the converter removes all Reaction objects in the
    model after it is done.

    Configuration and use of SBMLReactionConverter
    ======================================================================

    SBMLReactionConverter is enabled by creating a ConversionProperties
    object with the option ''replaceReactions',' and passing this
    properties object to SBMLDocument.convert().  This converter does not
    offer any additional configuration options.

    General information about the use of SBML converters
    ======================================================================

    The use of all the converters follows a similar approach.  First, one
    creates a ConversionProperties object and calls
    ConversionProperties.addOption() on this object with one argument: a
    text string that identifies the desired converter.  (The text string
    is specific to each converter; consult the documentation for a given
    converter to find out how it should be enabled.)

    Next, for some converters, the caller can optionally set some
    converter-specific properties using additional calls to
    ConversionProperties.addOption(). Many converters provide the ability
    to configure their behavior to some extent; this is realized through
    the use of properties that offer different options.  The default
    property values for each converter can be interrogated using the
    method SBMLConverter.getDefaultProperties() on the converter class in
    question .

    Finally, the caller should invoke the method SBMLDocument.convert()
    with the ConversionProperties object as an argument.

    Example of invoking an SBML converter
    ......................................................................

    The following code fragment illustrates an example using
    SBMLReactionConverter, which is invoked using the option string
    ''replaceReactions':'

      config = ConversionProperties()
      if config != None:
        config.addOption('replaceReactions')

    In the case of SBMLReactionConverter, there are no options to affect
    its behavior, so the next step is simply to invoke the converter on an
    SBMLDocument object.  Continuing the example code:

        # Assume that the variable 'document' has been set to an SBMLDocument object.
        status = document.convert(config)
        if status != LIBSBML_OPERATION_SUCCESS:
          # Handle error somehow.
          print('Error: conversion failed due to the following:')
          document.printErrors()

    Here is an example of using a converter that offers an option. The
    following code invokes SBMLStripPackageConverter to remove the SBML
    Level 3 Layout package from a model.  It sets the name of the package
    to be removed by adding a value for the option named ''package''
    defined by that converter:

      def strip_layout_example(document):
        config = ConversionProperties()
        if config != None:
          config.addOption('stripPackage')
          config.addOption('package', 'layout')
          status = document.convert(config)
          if status != LIBSBML_OPERATION_SUCCESS:
            # Handle error somehow.
            print('Error: unable to strip the Layout package.')
            print('LibSBML returned error: ' + OperationReturnValue_toString(status).strip())
        else:
          # Handle error somehow.
          print('Error: unable to create ConversionProperties object')

    Available SBML converters in libSBML
    ......................................................................

    LibSBML provides a number of built-in converters; by convention, their
    names end in Converter. The following are the built-in converters
    provided by libSBML 5.18.0 :

    @copydetails doc_list_of_libsbml_converters

    """

    __swig_setmethods__ = {}
    for _s in [SBMLConverter]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLReactionConverter, name, value)
    __swig_getmethods__ = {}
    for _s in [SBMLConverter]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SBMLReactionConverter, name)
    __repr__ = _swig_repr

    def init():
        """
        init()


        Internal implementation method.

        """
        return _libsbml.SBMLReactionConverter_init()

    init = staticmethod(init)

    def __init__(self, *args):
        """
        __init__(SBMLReactionConverter self) -> SBMLReactionConverter
        __init__(SBMLReactionConverter self, SBMLReactionConverter obj) -> SBMLReactionConverter


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            SBMLReactionConverter(SBMLReactionConverter obj)

        Copy constructor; creates a copy of an SBMLReactionConverter object.

        Parameter 'obj' is the SBMLReactionConverter object to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            SBMLReactionConverter()

        Creates a new SBMLReactionConverter object.

        """
        this = _libsbml.new_SBMLReactionConverter(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(SBMLReactionConverter self) -> SBMLReactionConverter


        Creates and returns a deep copy of this SBMLReactionConverter object.

        Returns a (deep) copy of this converter.

        """
        return _libsbml.SBMLReactionConverter_clone(self)

    __swig_destroy__ = _libsbml.delete_SBMLReactionConverter
    __del__ = lambda self: None

    def matchesProperties(self, props):
        """
        matchesProperties(SBMLReactionConverter self, ConversionProperties props) -> bool


        Returns 'True' if this converter object's properties match the given
        properties.

        A typical use of this method involves creating a ConversionProperties
        object, setting the options desired, and then calling this method on
        an SBMLReactionConverter object to find out if the object's property
        values match the given ones.  This method is also used by
        SBMLConverterRegistry.getConverterFor() to search across all
        registered converters for one matching particular properties.

        Parameter 'props' is the properties to match.

        Returns 'True' if this converter's properties match, 'False'
        otherwise.

        """
        return _libsbml.SBMLReactionConverter_matchesProperties(self, props)


    def convert(self):
        """
        convert(SBMLReactionConverter self) -> int


        Perform the conversion.

        This method causes the converter to do the actual conversion work,
        that is, to convert the SBMLDocument object set by
        SBMLConverter.setDocument() and with the configuration options set by
        SBMLConverter.setProperties().

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_CONV_INVALID_SRC_DOCUMENT

        """
        return _libsbml.SBMLReactionConverter_convert(self)


    def getDefaultProperties(self):
        """
        getDefaultProperties(SBMLReactionConverter self) -> ConversionProperties


        Returns the default properties of this converter.

        A given converter exposes one or more properties that can be adjusted
        in order to influence the behavior of the converter.  This method
        returns the default property settings for this converter.  It is meant
        to be called in order to discover all the settings for the converter
        object.

        Returns the ConversionProperties object describing the default
        properties for this converter.

        """
        return _libsbml.SBMLReactionConverter_getDefaultProperties(self)


    def setDocument(self, doc):
        """
        setDocument(SBMLReactionConverter self, SBMLDocument doc) -> int


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            setDocument(SBMLDocument doc)

        Sets the current SBML document to the given SBMLDocument object.

        Parameter 'doc' is the document to use for this conversion.

        WARNING:

        Even though the 'doc' is '', it is immediately cast to a non- version,
        which is then usually changed by the converter upon a successful
        conversion.  This function is here solely to preserve backwards
        compatibility.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        ______________________________________________________________________
        Method variant with the following signature:

            setDocument(SBMLDocument doc)

        Sets the current SBML document to the given SBMLDocument object.

        Parameter 'doc' is the document to use for this conversion.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.SBMLReactionConverter_setDocument(self, doc)

SBMLReactionConverter_swigregister = _libsbml.SBMLReactionConverter_swigregister
SBMLReactionConverter_swigregister(SBMLReactionConverter)

def SBMLReactionConverter_init():
    """
    SBMLReactionConverter_init()


    Internal implementation method.

    """
    return _libsbml.SBMLReactionConverter_init()

class SBMLRuleConverter(SBMLConverter):
    """

    Converter that sorts SBML rules and assignments.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  It is a class used in the
    implementation of extra functionality provided by libSBML.

    This converter reorders assignments in a model.  Specifically, it
    sorts the list of assignment rules (i.e., the AssignmentRule objects
    contained in the ListOfAssignmentRules within the Model object) and
    the initial assignments (i.e., the InitialAssignment objects contained
    in the ListOfInitialAssignments) such that, within each set,
    assignments that depend on prior values are placed after the values
    are set.  For example, if there is an assignment rule stating a = b +
    1, and another rule stating b = 3, the list of rules is sorted and the
    rules are arranged so that the rule for b = 3 appears before the rule
    for a = b + 1.  Similarly, if dependencies of this sort exist in the
    list of initial assignments in the model, the initial assignments are
    sorted as well.

    Beginning with SBML Level 2, assignment rules have no ordering
    required---the order in which the rules appear in an SBML file has no
    significance.  Software tools, however, may need to reorder
    assignments for purposes of evaluating them.  For example, for
    simulators that use time integration methods, it would be a good idea
    to reorder assignment rules such as the following,

    b = a + 10 seconds a = time

    so that the evaluation of the rules is independent of integrator step
    sizes. (This is due to the fact that, in this case, the order in which
    the rules are evaluated changes the result.)  SBMLRuleConverter can be
    used to reorder the SBML objects regardless of whether the input file
    contained them in the desired order.

    Note that the two sets of SBML assignments (list of assignment rules
    on the one hand, and list of initial assignments on the other hand)
    are handled independently.  In an SBML model, these entities are
    treated differently and no amount of sorting can deal with inter-
    dependencies between assignments of the two kinds. Configuration and use of SBMLRuleConverter
    ======================================================================

    SBMLRuleConverter is enabled by creating a ConversionProperties object
    with the option ''sortRules',' and passing this properties object to
    SBMLDocument.convert().  This converter offers no other options.

    General information about the use of SBML converters
    ======================================================================

    The use of all the converters follows a similar approach.  First, one
    creates a ConversionProperties object and calls
    ConversionProperties.addOption() on this object with one argument: a
    text string that identifies the desired converter.  (The text string
    is specific to each converter; consult the documentation for a given
    converter to find out how it should be enabled.)

    Next, for some converters, the caller can optionally set some
    converter-specific properties using additional calls to
    ConversionProperties.addOption(). Many converters provide the ability
    to configure their behavior to some extent; this is realized through
    the use of properties that offer different options.  The default
    property values for each converter can be interrogated using the
    method SBMLConverter.getDefaultProperties() on the converter class in
    question .

    Finally, the caller should invoke the method SBMLDocument.convert()
    with the ConversionProperties object as an argument.

    Example of invoking an SBML converter
    ......................................................................

    The following code fragment illustrates an example using
    SBMLReactionConverter, which is invoked using the option string
    ''replaceReactions':'

      config = ConversionProperties()
      if config != None:
        config.addOption('replaceReactions')

    In the case of SBMLReactionConverter, there are no options to affect
    its behavior, so the next step is simply to invoke the converter on an
    SBMLDocument object.  Continuing the example code:

        # Assume that the variable 'document' has been set to an SBMLDocument object.
        status = document.convert(config)
        if status != LIBSBML_OPERATION_SUCCESS:
          # Handle error somehow.
          print('Error: conversion failed due to the following:')
          document.printErrors()

    Here is an example of using a converter that offers an option. The
    following code invokes SBMLStripPackageConverter to remove the SBML
    Level 3 Layout package from a model.  It sets the name of the package
    to be removed by adding a value for the option named ''package''
    defined by that converter:

      def strip_layout_example(document):
        config = ConversionProperties()
        if config != None:
          config.addOption('stripPackage')
          config.addOption('package', 'layout')
          status = document.convert(config)
          if status != LIBSBML_OPERATION_SUCCESS:
            # Handle error somehow.
            print('Error: unable to strip the Layout package.')
            print('LibSBML returned error: ' + OperationReturnValue_toString(status).strip())
        else:
          # Handle error somehow.
          print('Error: unable to create ConversionProperties object')

    Available SBML converters in libSBML
    ......................................................................

    LibSBML provides a number of built-in converters; by convention, their
    names end in Converter. The following are the built-in converters
    provided by libSBML 5.18.0 :

    @copydetails doc_list_of_libsbml_converters

    """

    __swig_setmethods__ = {}
    for _s in [SBMLConverter]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLRuleConverter, name, value)
    __swig_getmethods__ = {}
    for _s in [SBMLConverter]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SBMLRuleConverter, name)
    __repr__ = _swig_repr

    def init():
        """
        init()


        Internal implementation method.

        """
        return _libsbml.SBMLRuleConverter_init()

    init = staticmethod(init)

    def __init__(self, *args):
        """
        __init__(SBMLRuleConverter self) -> SBMLRuleConverter
        __init__(SBMLRuleConverter self, SBMLRuleConverter obj) -> SBMLRuleConverter


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            SBMLRuleConverter(SBMLRuleConverter obj)

        Copy constructor; creates a copy of an SBMLLevelVersionConverter
        object.

        Parameter 'obj' is the SBMLLevelVersionConverter object to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            SBMLRuleConverter()

        Creates a new SBMLLevelVersionConverter object.

        """
        this = _libsbml.new_SBMLRuleConverter(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(SBMLRuleConverter self) -> SBMLRuleConverter


        Creates and returns a deep copy of this SBMLLevelVersionConverter
        object.

        Returns a (deep) copy of this converter.

        """
        return _libsbml.SBMLRuleConverter_clone(self)

    __swig_destroy__ = _libsbml.delete_SBMLRuleConverter
    __del__ = lambda self: None

    def matchesProperties(self, props):
        """
        matchesProperties(SBMLRuleConverter self, ConversionProperties props) -> bool


        Returns 'True' if this converter object's properties match the given
        properties.

        A typical use of this method involves creating a ConversionProperties
        object, setting the options desired, and then calling this method on
        an SBMLLevelVersionConverter object to find out if the object's
        property values match the given ones.  This method is also used by
        SBMLConverterRegistry.getConverterFor() to search across all
        registered converters for one matching particular properties.

        Parameter 'props' is the properties to match.

        Returns 'True' if this converter's properties match, 'False'
        otherwise.

        """
        return _libsbml.SBMLRuleConverter_matchesProperties(self, props)


    def convert(self):
        """
        convert(SBMLRuleConverter self) -> int


        Perform the conversion.

        This method causes the converter to do the actual conversion work,
        that is, to convert the SBMLDocument object set by
        SBMLConverter.setDocument() and with the configuration options set by
        SBMLConverter.setProperties().

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_CONV_INVALID_SRC_DOCUMENT

        """
        return _libsbml.SBMLRuleConverter_convert(self)


    def getDefaultProperties(self):
        """
        getDefaultProperties(SBMLRuleConverter self) -> ConversionProperties


        Returns the default properties of this converter.

        A given converter exposes one or more properties that can be adjusted
        in order to influence the behavior of the converter.  This method
        returns the default property settings for this converter.  It is meant
        to be called in order to discover all the settings for the converter
        object.

        Returns the ConversionProperties object describing the default
        properties for this converter.

        """
        return _libsbml.SBMLRuleConverter_getDefaultProperties(self)

SBMLRuleConverter_swigregister = _libsbml.SBMLRuleConverter_swigregister
SBMLRuleConverter_swigregister(SBMLRuleConverter)

def SBMLRuleConverter_init():
    """
    SBMLRuleConverter_init()


    Internal implementation method.

    """
    return _libsbml.SBMLRuleConverter_init()

class SBMLStripPackageConverter(SBMLConverter):
    """

    Converter that removes SBML Level 3 packages.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  It is a class used in the
    implementation of extra functionality provided by libSBML.

    This SBML converter takes an SBML document and removes (strips) an
    SBML Level 3 package from it.  No conversion is performed; the package
    constructs are simply removed from the SBML document.  The package to
    be stripped is determined by the value of the option ''package'' on
    the conversion properties.

    Configuration and use of SBMLStripPackageConverter
    ======================================================================

    SBMLStripPackageConverter is enabled by creating a
    ConversionProperties object with the option ''stripPackage',' and
    passing this properties object to SBMLDocument.convert(). This
    converter takes one required option:

    * ''package':' the value of this option should be a text string,
    the nickname of the SBML Level 3 package to be stripped from the
    model.

    In addition, the converter understands an additional optional:

    * ''stripAllUnrecognized':' if set to 'True,' the converter will
    remove all SBML Level 3 package constructs for Level 3 packages that
    this copy of libSBML does not recognize.  Note that what a given copy
    of libSBML recognizes is determined by which plug-ins it has been
    configured to include.  If this option is enabled, it may remove SBML
    Level 3 package constructs that are legitimate in the sense that they
    are officially defined SBML constructs, but not recognized because the
    running copy of libSBML has not had support enabled for them.

    General information about the use of SBML converters
    ======================================================================

    The use of all the converters follows a similar approach.  First, one
    creates a ConversionProperties object and calls
    ConversionProperties.addOption() on this object with one argument: a
    text string that identifies the desired converter.  (The text string
    is specific to each converter; consult the documentation for a given
    converter to find out how it should be enabled.)

    Next, for some converters, the caller can optionally set some
    converter-specific properties using additional calls to
    ConversionProperties.addOption(). Many converters provide the ability
    to configure their behavior to some extent; this is realized through
    the use of properties that offer different options.  The default
    property values for each converter can be interrogated using the
    method SBMLConverter.getDefaultProperties() on the converter class in
    question .

    Finally, the caller should invoke the method SBMLDocument.convert()
    with the ConversionProperties object as an argument.

    Example of invoking an SBML converter
    ......................................................................

    The following code fragment illustrates an example using
    SBMLReactionConverter, which is invoked using the option string
    ''replaceReactions':'

      config = ConversionProperties()
      if config != None:
        config.addOption('replaceReactions')

    In the case of SBMLReactionConverter, there are no options to affect
    its behavior, so the next step is simply to invoke the converter on an
    SBMLDocument object.  Continuing the example code:

        # Assume that the variable 'document' has been set to an SBMLDocument object.
        status = document.convert(config)
        if status != LIBSBML_OPERATION_SUCCESS:
          # Handle error somehow.
          print('Error: conversion failed due to the following:')
          document.printErrors()

    Here is an example of using a converter that offers an option. The
    following code invokes SBMLStripPackageConverter to remove the SBML
    Level 3 Layout package from a model.  It sets the name of the package
    to be removed by adding a value for the option named ''package''
    defined by that converter:

      def strip_layout_example(document):
        config = ConversionProperties()
        if config != None:
          config.addOption('stripPackage')
          config.addOption('package', 'layout')
          status = document.convert(config)
          if status != LIBSBML_OPERATION_SUCCESS:
            # Handle error somehow.
            print('Error: unable to strip the Layout package.')
            print('LibSBML returned error: ' + OperationReturnValue_toString(status).strip())
        else:
          # Handle error somehow.
          print('Error: unable to create ConversionProperties object')

    Available SBML converters in libSBML
    ......................................................................

    LibSBML provides a number of built-in converters; by convention, their
    names end in Converter. The following are the built-in converters
    provided by libSBML 5.18.0 :

    @copydetails doc_list_of_libsbml_converters

    """

    __swig_setmethods__ = {}
    for _s in [SBMLConverter]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLStripPackageConverter, name, value)
    __swig_getmethods__ = {}
    for _s in [SBMLConverter]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SBMLStripPackageConverter, name)
    __repr__ = _swig_repr

    def init():
        """
        init()


        Internal implementation method.

        """
        return _libsbml.SBMLStripPackageConverter_init()

    init = staticmethod(init)

    def __init__(self, *args):
        """
        __init__(SBMLStripPackageConverter self) -> SBMLStripPackageConverter
        __init__(SBMLStripPackageConverter self, SBMLStripPackageConverter obj) -> SBMLStripPackageConverter


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            SBMLStripPackageConverter()

        Creates a new SBMLStripPackageConverter object.

        ______________________________________________________________________
        Method variant with the following signature:

            SBMLStripPackageConverter(SBMLStripPackageConverter obj)

        Copy constructor; creates a copy of an SBMLStripPackageConverter
        object.

        Parameter 'obj' is the SBMLStripPackageConverter object to copy.

        """
        this = _libsbml.new_SBMLStripPackageConverter(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_SBMLStripPackageConverter
    __del__ = lambda self: None

    def clone(self):
        """
        clone(SBMLStripPackageConverter self) -> SBMLStripPackageConverter


        Creates and returns a deep copy of this SBMLStripPackageConverter
        object.

        Returns the (deep) copy of this converter object.

        """
        return _libsbml.SBMLStripPackageConverter_clone(self)


    def matchesProperties(self, props):
        """
        matchesProperties(SBMLStripPackageConverter self, ConversionProperties props) -> bool


        Returns 'True' if this converter object's properties match the given
        properties.

        A typical use of this method involves creating a ConversionProperties
        object, setting the options desired, and then calling this method on
        an SBMLStripPackageConverter object to find out if the object's
        property values match the given ones.  This method is also used by
        SBMLConverterRegistry.getConverterFor() to search across all
        registered converters for one matching particular properties.

        Parameter 'props' is the properties to match.

        Returns 'True' if this converter's properties match, 'False'
        otherwise.

        """
        return _libsbml.SBMLStripPackageConverter_matchesProperties(self, props)


    def convert(self):
        """
        convert(SBMLStripPackageConverter self) -> int


        Perform the conversion.

        This method causes the converter to do the actual conversion work,
        that is, to convert the SBMLDocument object set by
        SBMLConverter.setDocument() and with the configuration options set by
        SBMLConverter.setProperties().

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_CONV_PKG_CONSIDERED_UNKNOWN

        """
        return _libsbml.SBMLStripPackageConverter_convert(self)


    def getDefaultProperties(self):
        """
        getDefaultProperties(SBMLStripPackageConverter self) -> ConversionProperties


        Returns the default properties of this converter.

        A given converter exposes one or more properties that can be adjusted
        in order to influence the behavior of the converter.  This method
        returns the default property settings for this converter.  It is meant
        to be called in order to discover all the settings for the converter
        object.

        Returns the ConversionProperties object describing the default
        properties for this converter.

        """
        return _libsbml.SBMLStripPackageConverter_getDefaultProperties(self)


    def getPackageToStrip(self):
        """
        getPackageToStrip(SBMLStripPackageConverter self) -> string


        Returns the package to be stripped.

        """
        return _libsbml.SBMLStripPackageConverter_getPackageToStrip(self)


    def isStripAllUnrecognizedPackages(self):
        """
        isStripAllUnrecognizedPackages(SBMLStripPackageConverter self) -> bool


        Returns a boolean indicating whether all unrecognized packages should
        be removed.

        """
        return _libsbml.SBMLStripPackageConverter_isStripAllUnrecognizedPackages(self)

SBMLStripPackageConverter_swigregister = _libsbml.SBMLStripPackageConverter_swigregister
SBMLStripPackageConverter_swigregister(SBMLStripPackageConverter)

def SBMLStripPackageConverter_init():
    """
    SBMLStripPackageConverter_init()


    Internal implementation method.

    """
    return _libsbml.SBMLStripPackageConverter_init()

class SBMLUnitsConverter(SBMLConverter):
    """

    Converts a model's existing units to SI units.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  It is a class used in the
    implementation of extra functionality provided by libSBML.

    This SBML converter converts the units in a model to base SI units,
    that is, using only the units metre, kilogram, second, ampere, kelvin,
    mole and candela.

    Unit conversion will only be performed on models that are fully unit
    consistent, meaning that all objects have units associated with them
    and there are no literal numbers with unspecified units.  In the case
    of an SBML Level 3 model involving math expressions, this means that
    the 'timeUnits' attribute on the Model object must be set, and if
    there are any reactions in the model, the 'extentUnits' attribute on
    the Model object must also be set.

    Configuration and use of SBMLUnitsConverter
    ======================================================================

    SBMLUnitsConverter is enabled by creating a ConversionProperties
    object with the option ''units',' and passing this properties object
    to SBMLDocument.convert().  This converter takes one optional option:

    * ''removeUnusedUnits':' the value of this property should be a
    Boolean.  If it is 'True,' it tells the unit convert to remove any
    unused UnitDefinition objects after conversion is complete.  ('Unused'
    units are units that are not referenced by any object in the model.)
    If the value is 'False,' unused UnitDefinition objects are not removed
    from the model. The default is 'True.'

    General information about the use of SBML converters
    ======================================================================

    The use of all the converters follows a similar approach.  First, one
    creates a ConversionProperties object and calls
    ConversionProperties.addOption() on this object with one argument: a
    text string that identifies the desired converter.  (The text string
    is specific to each converter; consult the documentation for a given
    converter to find out how it should be enabled.)

    Next, for some converters, the caller can optionally set some
    converter-specific properties using additional calls to
    ConversionProperties.addOption(). Many converters provide the ability
    to configure their behavior to some extent; this is realized through
    the use of properties that offer different options.  The default
    property values for each converter can be interrogated using the
    method SBMLConverter.getDefaultProperties() on the converter class in
    question .

    Finally, the caller should invoke the method SBMLDocument.convert()
    with the ConversionProperties object as an argument.

    Example of invoking an SBML converter
    ......................................................................

    The following code fragment illustrates an example using
    SBMLReactionConverter, which is invoked using the option string
    ''replaceReactions':'

      config = ConversionProperties()
      if config != None:
        config.addOption('replaceReactions')

    In the case of SBMLReactionConverter, there are no options to affect
    its behavior, so the next step is simply to invoke the converter on an
    SBMLDocument object.  Continuing the example code:

        # Assume that the variable 'document' has been set to an SBMLDocument object.
        status = document.convert(config)
        if status != LIBSBML_OPERATION_SUCCESS:
          # Handle error somehow.
          print('Error: conversion failed due to the following:')
          document.printErrors()

    Here is an example of using a converter that offers an option. The
    following code invokes SBMLStripPackageConverter to remove the SBML
    Level 3 Layout package from a model.  It sets the name of the package
    to be removed by adding a value for the option named ''package''
    defined by that converter:

      def strip_layout_example(document):
        config = ConversionProperties()
        if config != None:
          config.addOption('stripPackage')
          config.addOption('package', 'layout')
          status = document.convert(config)
          if status != LIBSBML_OPERATION_SUCCESS:
            # Handle error somehow.
            print('Error: unable to strip the Layout package.')
            print('LibSBML returned error: ' + OperationReturnValue_toString(status).strip())
        else:
          # Handle error somehow.
          print('Error: unable to create ConversionProperties object')

    Available SBML converters in libSBML
    ......................................................................

    LibSBML provides a number of built-in converters; by convention, their
    names end in Converter. The following are the built-in converters
    provided by libSBML 5.18.0 :

    @copydetails doc_list_of_libsbml_converters

    """

    __swig_setmethods__ = {}
    for _s in [SBMLConverter]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLUnitsConverter, name, value)
    __swig_getmethods__ = {}
    for _s in [SBMLConverter]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SBMLUnitsConverter, name)
    __repr__ = _swig_repr

    def init():
        """
        init()


        Internal implementation method.

        """
        return _libsbml.SBMLUnitsConverter_init()

    init = staticmethod(init)

    def __init__(self, *args):
        """
        __init__(SBMLUnitsConverter self) -> SBMLUnitsConverter
        __init__(SBMLUnitsConverter self, SBMLUnitsConverter obj) -> SBMLUnitsConverter


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            SBMLUnitsConverter()

        Creates a new SBMLUnitsConverter object.

        ______________________________________________________________________
        Method variant with the following signature:

            SBMLUnitsConverter(SBMLUnitsConverter obj)

        Copy constructor; creates a copy of an SBMLUnitsConverter object.

        Parameter 'obj' is the SBMLUnitsConverter object to copy.

        """
        this = _libsbml.new_SBMLUnitsConverter(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_SBMLUnitsConverter
    __del__ = lambda self: None

    def clone(self):
        """
        clone(SBMLUnitsConverter self) -> SBMLUnitsConverter


        Creates and returns a deep copy of this SBMLUnitsConverter object.

        Returns a (deep) copy of this converter.

        """
        return _libsbml.SBMLUnitsConverter_clone(self)


    def matchesProperties(self, props):
        """
        matchesProperties(SBMLUnitsConverter self, ConversionProperties props) -> bool


        Returns 'True' if this converter object's properties match the given
        properties.

        A typical use of this method involves creating a ConversionProperties
        object, setting the options desired, and then calling this method on
        an SBMLUnitsConverter object to find out if the object's property
        values match the given ones.  This method is also used by
        SBMLConverterRegistry.getConverterFor() to search across all
        registered converters for one matching particular properties.

        Parameter 'props' is the properties to match.

        Returns 'True' if this converter's properties match, 'False'
        otherwise.

        """
        return _libsbml.SBMLUnitsConverter_matchesProperties(self, props)


    def convert(self):
        """
        convert(SBMLUnitsConverter self) -> int


        Perform the conversion.

        This method causes the converter to do the actual conversion work,
        that is, to convert the SBMLDocument object set by
        SBMLConverter.setDocument() and with the configuration options set by
        SBMLConverter.setProperties().

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_CONV_CONVERSION_NOT_AVAILABLE

        * LIBSBML_CONV_INVALID_SRC_DOCUMENT

        """
        return _libsbml.SBMLUnitsConverter_convert(self)


    def getDefaultProperties(self):
        """
        getDefaultProperties(SBMLUnitsConverter self) -> ConversionProperties


        Returns the default properties of this converter.

        A given converter exposes one or more properties that can be adjusted
        in order to influence the behavior of the converter.  This method
        returns the default property settings for this converter.  It is meant
        to be called in order to discover all the settings for the converter
        object.

        Returns the ConversionProperties object describing the default
        properties for this converter.

        """
        return _libsbml.SBMLUnitsConverter_getDefaultProperties(self)

SBMLUnitsConverter_swigregister = _libsbml.SBMLUnitsConverter_swigregister
SBMLUnitsConverter_swigregister(SBMLUnitsConverter)

def SBMLUnitsConverter_init():
    """
    SBMLUnitsConverter_init()


    Internal implementation method.

    """
    return _libsbml.SBMLUnitsConverter_init()

class SBMLValidator(_object):
    """

    Base class for SBML validators.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    LibSBML implements facilities for verifying that a given SBML
    document is valid according to the SBML specifications; it also
    exposes the validation interface so that user programs and SBML Level
    3 package authors may use the facilities to implement new validators.
    There are two main interfaces to libSBML's validation facilities,
    based on the classes Validator and SBMLValidator.

    The Validator class is the basis of the system for validating an SBML
    document against the validation rules defined in the SBML
    specifications.  The scheme used by Validator relies is compact and
    uses the visitor programming pattern, but it relies on C/C++ features
    and is not directly accessible from language bindings.  SBMLValidator
    offers a framework for straightforward class-based extensibility, so
    that user code can subclass SBMLValidator to implement new validation
    systems, different validators can be introduced or turned off at run-
    time, and interfaces can be provided in the libSBML language bindings.
    SBMLValidator can call Validator functionality internally (as is the
    case in the current implementation of SBMLInternalValidator) or use
    entirely different implementation approaches, as necessary.

    Users of libSBML may already be familiar with the facilities
    encompassed by the validation system, in the form of the consistency-
    checking methods defined on SBMLDocument.  The methods
    SBMLDocument.setConsistencyChecks(), SBMLDocument.checkConsistency(),
    SBMLDocument.checkInternalConsistency() and other method of that sort
    are in fact implemented via SBMLValidator, specifically as methods on
    the class SBMLInternalValidator.

    Authors may use SBMLValidator as the base class for their own
    validator extensions to libSBML.  The class SBMLInternalValidator may
    serve as a code example for how to implement such things.

    """

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLValidator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SBMLValidator, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(SBMLValidator self) -> SBMLValidator
        __init__(SBMLValidator self, SBMLValidator orig) -> SBMLValidator


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            SBMLValidator()

        Creates a new SBMLValidator.

        ______________________________________________________________________
        Method variant with the following signature:

            SBMLValidator(SBMLValidator orig)

        Copy constructor; creates a copy of an SBMLValidator object.

        Parameter 'orig' is the object to copy.

        """
        if self.__class__ == SBMLValidator:
            _self = None
        else:
            _self = self
        this = _libsbml.new_SBMLValidator(_self, *args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_SBMLValidator
    __del__ = lambda self: None

    def clone(self):
        """
        clone(SBMLValidator self) -> SBMLValidator


        Creates and returns a deep copy of this SBMLValidator object.

        Returns the (deep) copy of this SBMLValidator object.

        """
        return _libsbml.SBMLValidator_clone(self)


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


        Returns the current SBML document in use by this validator.

        Returns the current SBML document.

        See also setDocument().

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


    def setDocument(self, doc):
        """
        setDocument(SBMLValidator self, SBMLDocument doc) -> int


        Sets the current SBML document to the given SBMLDocument object.

        Parameter 'doc' is the document to use for this validation.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        See also getDocument().

        """
        return _libsbml.SBMLValidator_setDocument(self, doc)


    def clearFailures(self):
        """
        clearFailures(SBMLValidator self)


        Clears this validator's list of failures.

        If you are validating multiple SBML documents with the same validator,
        call this method after you have processed the list of failures from
        the last validation run and before validating the next document.

        """
        return _libsbml.SBMLValidator_clearFailures(self)


    def logFailure(self, err):
        """
        logFailure(SBMLValidator self, SBMLError err)


        Adds the given failure to this list of Validators failures.

        Parameter 'err' is an SBMLError object representing an error or
        warning.

        """
        return _libsbml.SBMLValidator_logFailure(self, err)


    def validate(self, *args):
        """
        validate(SBMLValidator self) -> unsigned int
        validate(SBMLValidator self, SBMLDocument d) -> unsigned int
        validate(SBMLValidator self, string filename) -> unsigned int


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            validate(string filename)

        Validates the SBML document located at the given 'filename'.

        This is a convenience method that saves callers the trouble of using
        SBMLReader to read the document first.

        Parameter 'filename' is the path to the file to be read and validated.

        Returns the number of validation failures that occurred.  The objects
        describing the actual failures can be retrieved using getFailures().

        ______________________________________________________________________
        Method variant with the following signature:

            validate()

        Runs this validator on the current SBML document.

        Returns an integer value indicating the success/failure of the
        validation.   The possible values returned by this function are
        determined by the specific subclasses of this class.

        ______________________________________________________________________
        Method variant with the following signature:

            validate(SBMLDocument d)

        Validates the given SBMLDocument object.

        This is identical to calling setDocument() followed by validate().

        Parameter 'd' is the SBML document to validate.

        Returns the number of validation failures that occurred.  The objects
        describing the actual failures can be retrieved using getFailures().

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


    def getErrorLog(self):
        """
        getErrorLog(SBMLValidator self) -> SBMLErrorLog


        Returns the list of errors or warnings logged during parsing,
        consistency checking, or attempted translation of this model.

        Note that this refers to the SBMLDocument object's error log (i.e.,
        the list returned by SBMLDocument.getErrorLog()).  That list of errors
        and warnings is separate from the validation failures tracked by this
        validator (i.e., the list returned by getFailures()).

        Returns the SBMLErrorLog used for the SBMLDocument.

        """
        return _libsbml.SBMLValidator_getErrorLog(self)


    def getModel(self, *args):
        """
        getModel(SBMLValidator self) -> Model
        getModel(SBMLValidator self) -> Model


        Returns the Model object stored in the SBMLDocument.

        It is important to note that this method does not create a Model
        instance.  The model in the SBMLDocument must have been created at
        some prior time, for example using SBMLDocument.createModel()  or
        SBMLDocument.setModel(). This method returns 'None' if a model does
        not yet exist.

        Returns the Model contained in this validator's SBMLDocument object.

        See also SBMLDocument.setModel(), SBMLDocument.createModel().

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


    def getNumFailures(self):
        """
        getNumFailures(SBMLValidator self) -> unsigned int


        Returns the number of failures encountered in the last validation run.

        This method returns the number of failures logged by this validator.
        This number only reflects this validator's actions; the number may not
        be the same as the number of errors and warnings logged on the
        SBMLDocument object's error log (i.e., the object returned by
        SBMLDocument.getErrorLog()), because other parts of libSBML may log
        errors and warnings beyond those found by this validator.

        Returns the number of errors logged by this validator.

        """
        return _libsbml.SBMLValidator_getNumFailures(self)


    def getFailure(self, n):
        """
        getFailure(SBMLValidator self, unsigned int n) -> SBMLError


        Returns the failure object at index n in this validator's list of
        failures logged during the last run.

        Callers should use getNumFailures() first, to find out the number of
        entries in this validator's list of failures.

        Parameter 'n' is an integer indicating the index of the object to
        return from the failures list; index values start at 0.

        Returns the failure at the given index number.

        See also getNumFailures().

        """
        return _libsbml.SBMLValidator_getFailure(self, n)

    def __disown__(self):
        self.this.disown()
        _libsbml.disown_SBMLValidator(self)
        return weakref_proxy(self)
SBMLValidator_swigregister = _libsbml.SBMLValidator_swigregister
SBMLValidator_swigregister(SBMLValidator)

class SBMLExternalValidator(SBMLValidator):
    """

    Internal implementation method.

    """

    __swig_setmethods__ = {}
    for _s in [SBMLValidator]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLExternalValidator, name, value)
    __swig_getmethods__ = {}
    for _s in [SBMLValidator]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SBMLExternalValidator, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(SBMLExternalValidator self) -> SBMLExternalValidator
        __init__(SBMLExternalValidator self, SBMLExternalValidator orig) -> SBMLExternalValidator


        Internal implementation method.

        """
        this = _libsbml.new_SBMLExternalValidator(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(SBMLExternalValidator self) -> SBMLValidator


        Internal implementation method.

        """
        return _libsbml.SBMLExternalValidator_clone(self)

    __swig_destroy__ = _libsbml.delete_SBMLExternalValidator
    __del__ = lambda self: None

    def validate(self):
        """
        validate(SBMLExternalValidator self) -> unsigned int


        Internal implementation method.

        """
        return _libsbml.SBMLExternalValidator_validate(self)


    def getProgram(self):
        """
        getProgram(SBMLExternalValidator self) -> string


        Internal implementation method.

        """
        return _libsbml.SBMLExternalValidator_getProgram(self)


    def setProgram(self, program):
        """
        setProgram(SBMLExternalValidator self, string program)


        Internal implementation method.

        """
        return _libsbml.SBMLExternalValidator_setProgram(self, program)


    def getOutputFileName(self):
        """
        getOutputFileName(SBMLExternalValidator self) -> string


        Internal implementation method.

        """
        return _libsbml.SBMLExternalValidator_getOutputFileName(self)


    def setOutputFileName(self, outputFileName):
        """
        setOutputFileName(SBMLExternalValidator self, string outputFileName)


        Internal implementation method.

        """
        return _libsbml.SBMLExternalValidator_setOutputFileName(self, outputFileName)


    def getSBMLFileName(self):
        """
        getSBMLFileName(SBMLExternalValidator self) -> string


        Internal implementation method.

        """
        return _libsbml.SBMLExternalValidator_getSBMLFileName(self)


    def setSBMLFileName(self, sbmlFileName):
        """
        setSBMLFileName(SBMLExternalValidator self, string sbmlFileName)


        Internal implementation method.

        """
        return _libsbml.SBMLExternalValidator_setSBMLFileName(self, sbmlFileName)


    def clearArguments(self):
        """
        clearArguments(SBMLExternalValidator self)


        Internal implementation method.

        """
        return _libsbml.SBMLExternalValidator_clearArguments(self)


    def addArgument(self, arg):
        """
        addArgument(SBMLExternalValidator self, string arg)


        Internal implementation method.

        """
        return _libsbml.SBMLExternalValidator_addArgument(self, arg)


    def getNumArguments(self):
        """
        getNumArguments(SBMLExternalValidator self) -> unsigned int


        Internal implementation method.

        """
        return _libsbml.SBMLExternalValidator_getNumArguments(self)


    def getArgument(self, n):
        """
        getArgument(SBMLExternalValidator self, unsigned int n) -> string


        Internal implementation method.

        """
        return _libsbml.SBMLExternalValidator_getArgument(self, n)

SBMLExternalValidator_swigregister = _libsbml.SBMLExternalValidator_swigregister
SBMLExternalValidator_swigregister(SBMLExternalValidator)

class XMLAttributes(_object):
    """

    A list of attributes on an XML element.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    In libSBML's XML interface layer, attributes on an element are stored
    as a list of values kept in an XMLAttributes object.  XMLAttributes
    has methods for adding and removing individual attributes as well as
    performing other actions on the list of attributes.  Classes in
    libSBML that represent nodes in an XML document (i.e., XMLNode and its
    parent class, XMLToken) use XMLAttributes objects to manage attributes
    on XML elements.

    Attributes on an XML element can be written in one of two forms:

    * name='value'

    * prefix:name='value'

    An attribute in XML must always have a value, and the value must
    always be a quoted string; i.e., it is always name='value' and not
    name=value.  An empty value is represented simply as an empty string;
    i.e., name=''.

    In cases when a prefix is provided with an attribute name, general XML
    validity rules require that the prefix is an XML namespace prefix that
    has been declared somewhere else (possibly as an another attribute on
    the same element).  However, the XMLAttributes class does not test for
    the proper existence or declaration of XML namespaces -- callers must
    arrange to do this themselves in some other way.  This class only
    provides facilities for tracking and manipulating attributes and their
    prefix/URI/name/value components.

    Note: Note that although XMLAttributes provides operations that can
    manipulate attributes based on a numerical index, XML attributes are
    in fact unordered when they appear in files and data streams.  The
    XMLAttributes class provides some list-like facilities, but it is only
    for the convenience of callers.  (For example, it permits callers to
    loop across all attributes more easily.)  Users should keep in mind
    that the order in which attributes are stored in XMLAttributes objects
    has no real impact on the order in which the attributes are read or
    written from an XML file or data stream.

    See also XMLTriple, XMLNode, XMLToken.

    """

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, XMLAttributes, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, XMLAttributes, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_XMLAttributes
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(XMLAttributes self) -> XMLAttributes
        __init__(XMLAttributes self, XMLAttributes orig) -> XMLAttributes


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            XMLAttributes()

        Creates a new, empty XMLAttributes object.

        ______________________________________________________________________
        Method variant with the following signature:

            XMLAttributes(XMLAttributes orig)

        Copy constructor; creates a copy of this XMLAttributes object.

        'orig' the XMLAttributes object to copy.

        """
        this = _libsbml.new_XMLAttributes(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(XMLAttributes self) -> XMLAttributes


        Creates and returns a deep copy of this XMLAttributes object.

        Returns the (deep) copy of this XMLAttributes object.

        """
        return _libsbml.XMLAttributes_clone(self)


    def add(self, *args):
        """
        add(XMLAttributes self, string name, string value, string namespaceURI, string prefix) -> int
        add(XMLAttributes self, string name, string value, string namespaceURI) -> int
        add(XMLAttributes self, string name, string value) -> int
        add(XMLAttributes self, XMLTriple triple, string value) -> int


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            add(  string name , string value , string namespaceURI = '' ,
        string prefix = '')

        Adds an attribute to this list of attributes.

        Some explanations are in order about the behavior of XMLAttributes
        with respect to namespace prefixes and namespace URIs.  XMLAttributes
        does not verify the consistency of different uses of an XML namespace
        and the prefix used to refer to it in a given context.  It cannot,
        because the prefix used for a given XML namespace in an XML document
        may intentionally be different on different elements in the document.
        Consequently, callers need to manage their own prefix-to-namespace
        mappings, and need to ensure that the desired prefix is used in any
        given context.

        When called with attribute names, prefixes and namespace URIs,
        XMLAttributes pays attention to the namespace URIs and not the
        prefixes: a match is established by a combination of attribute name
        and namespace URI, and if on different occasions a different prefix is
        used for the same name/namespace combination, the prefix associated
        with the namespace on that attribute is overwritten.

        Some examples will hopefully clarify this.  Here are the results of a
        sequence of calls to the XMLAttributes add methods with different
        argument combinations.  First, we create the object and add one
        attribute:

          XMLAttributes  att = new XMLAttributes();
          att->add('myattribute', '1', 'myuri');

        The above adds an attribute named myattribute in the namespace myuri,
        and with the attribute value 1.  No namespace prefix is associated
        with the attribute (but the attribute is recorded to exist in the
        namespace myuri).  If this attribute object were written out in XML,
        it would look like the following (and note that, since no namespace
        prefix was assigned, none is written out): <center>

          myattribute='1'

        </center>

        Continuing with this series of examples, suppose we invoke the add
        method again as follows:

          att->add('myattribute', '2');

        The above adds a new attribute also named myattribute, but in a
        different XML namespace: it is placed in the namespace with no URI,
        which is to say, the default XML namespace.  Both attributes coexist
        on this XMLAttributes object; both can be independently retrieved.

          att->add('myattribute', '3');

        The code above now replaces the value of the attribute myattribute
        that resides in the default namespace.  The attribute in the namespace
        myuri remains untouched.

          att->add('myattribute', '4', 'myuri');

        The code above replaces the value of the attribute myattribute that
        resides in the myuri namespace. The attribute in the default namespace
        remains untouched.

          att->add('myattribute', '5', 'myuri', 'foo');

        The code above replaces the value of the attribute myattribute that
        resides in the myuri namespace. It also now assigns a namespace
        prefix, foo, to the attribute. The attribute myattribute in the
        default namespace remains untouched. If this XMLAttributes object were
        written out in XML, it would look like the following: <center>

          myattribute='3'
          foo:myattribute='5'

        </center> Pressing on, now suppose we call the add method as follows:

          att->add('myattribute', '6', 'myuri', 'bar');

        The code above replaces the value of the attribute myattribute that
        resides in the myuri namespace. It also assigns a different prefix to
        the attribute.  The namespace of the attribute remains myuri.

          att->add('myattribute', '7', '', 'foo');

        The code above replaces the value of the attribute myattribute that
        resides in the default namespace.  It also now assigns a namespace
        prefix, foo, to that attribute.  If this XMLAttributes object were
        written out in XML, it would look like the following: <center>

          bar:myattribute='6'
          foo:myattribute='7'

        </center>

        Parameter 'name' is a string, the unprefixed name of the attribute.
        Parameter 'value' is a string, the value of the attribute. Parameter
        'namespaceURI' is a string, the namespace URI of the attribute.
        Parameter 'prefix' is a string, a prefix for the XML namespace.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_OBJECT - this value is returned if any of the
        arguments are 'None.'  To set an empty 'prefix' and/or 'name' value,
        use an empty string rather than 'None.'

        Note: If an attribute with the same name and XML namespace URI already
        exists in the list of attributes held by this XMLAttributes object,
        then the previous value of that attribute will be replaced with the
        new value provided to this method.

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        See also add(), getIndex(), getIndex(), hasAttribute(),
        hasAttribute().

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            add( XMLTriple triple, string value)

        Adds an attribute to this list of attributes.

        Some explanations are in order about the behavior of XMLAttributes
        with respect to namespace prefixes and namespace URIs.  XMLAttributes
        does not verify the consistency of different uses of an XML namespace
        and the prefix used to refer to it in a given context.  It cannot,
        because the prefix used for a given XML namespace in an XML document
        may intentionally be different on different elements in the document.
        Consequently, callers need to manage their own prefix-to-namespace
        mappings, and need to ensure that the desired prefix is used in any
        given context.

        When called with attribute names, prefixes and namespace URIs,
        XMLAttributes pays attention to the namespace URIs and not the
        prefixes: a match is established by a combination of attribute name
        and namespace URI, and if on different occasions a different prefix is
        used for the same name/namespace combination, the prefix associated
        with the namespace on that attribute is overwritten.

        Some examples will hopefully clarify this.  Here are the results of a
        sequence of calls to the XMLAttributes add methods with different
        argument combinations.  First, we create the object and add one
        attribute:

          XMLAttributes  att = new XMLAttributes();
          att->add('myattribute', '1', 'myuri');

        The above adds an attribute named myattribute in the namespace myuri,
        and with the attribute value 1.  No namespace prefix is associated
        with the attribute (but the attribute is recorded to exist in the
        namespace myuri).  If this attribute object were written out in XML,
        it would look like the following (and note that, since no namespace
        prefix was assigned, none is written out): <center>

          myattribute='1'

        </center>

        Continuing with this series of examples, suppose we invoke the add
        method again as follows:

          att->add('myattribute', '2');

        The above adds a new attribute also named myattribute, but in a
        different XML namespace: it is placed in the namespace with no URI,
        which is to say, the default XML namespace.  Both attributes coexist
        on this XMLAttributes object; both can be independently retrieved.

          att->add('myattribute', '3');

        The code above now replaces the value of the attribute myattribute
        that resides in the default namespace.  The attribute in the namespace
        myuri remains untouched.

          att->add('myattribute', '4', 'myuri');

        The code above replaces the value of the attribute myattribute that
        resides in the myuri namespace. The attribute in the default namespace
        remains untouched.

          att->add('myattribute', '5', 'myuri', 'foo');

        The code above replaces the value of the attribute myattribute that
        resides in the myuri namespace. It also now assigns a namespace
        prefix, foo, to the attribute. The attribute myattribute in the
        default namespace remains untouched. If this XMLAttributes object were
        written out in XML, it would look like the following: <center>

          myattribute='3'
          foo:myattribute='5'

        </center> Pressing on, now suppose we call the add method as follows:

          att->add('myattribute', '6', 'myuri', 'bar');

        The code above replaces the value of the attribute myattribute that
        resides in the myuri namespace. It also assigns a different prefix to
        the attribute.  The namespace of the attribute remains myuri.

          att->add('myattribute', '7', '', 'foo');

        The code above replaces the value of the attribute myattribute that
        resides in the default namespace.  It also now assigns a namespace
        prefix, foo, to that attribute.  If this XMLAttributes object were
        written out in XML, it would look like the following: <center>

          bar:myattribute='6'
          foo:myattribute='7'

        </center>

        Parameter 'triple' is an XMLTriple object describing the attribute to
        be added. Parameter 'value' is a string, the value of the attribute.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_OBJECT - this value is returned if any of the
        arguments are 'None.'  To set an empty value for the attribute, use an
        empty string rather than 'None.'

        Note: If an attribute with the same name and XML namespace URI already
        exists in the list of attributes held by this XMLAttributes object,
        then the previous value of that attribute will be replaced with the
        new value provided to this method.

        See also add(), getIndex(), getIndex(), hasAttribute(),
        hasAttribute().

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


    def removeResource(self, n):
        """
        removeResource(XMLAttributes self, int n) -> int


        Internal implementation method.

        """
        return _libsbml.XMLAttributes_removeResource(self, n)


    def remove(self, *args):
        """
        remove(XMLAttributes self, int n) -> int
        remove(XMLAttributes self, string name, string uri) -> int
        remove(XMLAttributes self, string name) -> int
        remove(XMLAttributes self, XMLTriple triple) -> int


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string name, string uri = '')

        Removes a named attribute from this list of attributes.

        Parameter 'name' is a string, the unprefixed name of the attribute to
        be removed.

        Parameter 'uri' is a string, the namespace URI of the attribute to be
        removed.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INDEX_EXCEEDS_SIZE

        The value LIBSBML_INDEX_EXCEEDS_SIZE is returned if there is no
        attribute with the given 'name' (and 'uri' if specified).

        See also remove(), remove().

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(int n)

        Removes the nth attribute from this list of attributes.

        Parameter 'n' is an integer the index of the resource to be deleted.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INDEX_EXCEEDS_SIZE

        The value LIBSBML_INDEX_EXCEEDS_SIZE is returned if there is no
        attribute at the given index 'n'.

        Note: Note that although XMLAttributes provides operations that can
        manipulate attributes based on a numerical index, XML attributes are
        in fact unordered when they appear in files and data streams.  The
        XMLAttributes class provides some list-like facilities, but it is only
        for the convenience of callers.  (For example, it permits callers to
        loop across all attributes more easily.)  Users should keep in mind
        that the order in which attributes are stored in XMLAttributes objects
        has no real impact on the order in which the attributes are read or
        written from an XML file or data stream.

        See also getLength(), remove(), remove().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(XMLTriple triple)

        Removes a specific attribute from this list of attributes.

        Parameter 'triple' is an XMLTriple describing the attribute to be
        removed.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INDEX_EXCEEDS_SIZE

        The value LIBSBML_INDEX_EXCEEDS_SIZE is returned if there is no
        attribute matching the properties of the given 'triple'.

        See also remove(), remove().

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


    def clear(self):
        """
        clear(XMLAttributes self) -> int


        Removes all attributes in this XMLAttributes object.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        See also remove(), remove(), remove().

        """
        return _libsbml.XMLAttributes_clear(self)


    def getIndex(self, *args):
        """
        getIndex(XMLAttributes self, string name) -> int
        getIndex(XMLAttributes self, string name, string uri) -> int
        getIndex(XMLAttributes self, XMLTriple triple) -> int


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getIndex(XMLTriple triple)

        Returns the index of the attribute defined by the given XMLTriple
        object.

        Parameter 'triple' is an XMLTriple describing the attribute being
        sought.

        Returns the index of an attribute described by the given XMLTriple
        object, or -1 if no such attribute is present.

        See also hasAttribute(), hasAttribute().

        ______________________________________________________________________
        Method variant with the following signature:

            getIndex(string name, string uri)

        Returns the index of the attribute having a given name and XML
        namespace URI.

        Parameter 'name' is a string, the name of the attribute being sought.
        Parameter 'uri' is a string, the namespace URI of the attribute being
        sought.

        Returns the index of an attribute with the given local name and
        namespace URI, or -1 if no such attribute is present.

        See also hasAttribute(), hasAttribute().

        ______________________________________________________________________
        Method variant with the following signature:

            getIndex(string name)

        Returns the index of an attribute having a given name.

        Note: This method does not check XML namespaces.  Thus, if there are
        multiple attributes with the same local 'name' but different
        namespaces, this method will return the first one found.  Callers
        should use the more specific methods XMLAttributes.getIndex()  or
        XMLAttributes.getIndex()  to find attributes in particular namespaces.

        Parameter 'name' is a string, the name of the attribute whose index is
        begin sought.

        Returns the index of an attribute with the given local name, or -1 if
        no such attribute is present.

        See also hasAttribute(), hasAttribute().

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


    def getLength(self):
        """
        getLength(XMLAttributes self) -> int


        Returns the number of attributes in this list of attributes.

        Returns the number of attributes contained in this XMLAttributes
        object.

        """
        return _libsbml.XMLAttributes_getLength(self)


    def getNumAttributes(self):
        """
        getNumAttributes(XMLAttributes self) -> int


        Returns the number of attributes in this list of attributes.

        This function is merely an alias of XMLAttributes.getLength()
        introduced for consistency with other libXML classes.

        Returns the number of attributes contained in this XMLAttributes
        object.

        """
        return _libsbml.XMLAttributes_getNumAttributes(self)


    def getName(self, index):
        """
        getName(XMLAttributes self, int index) -> string


        Returns the name of the nth attribute in this list of attributes.

        Parameter 'index' is an integer, the position of the attribute whose
        name is being sought.

        Returns the local name of the nth attribute.

        Note: If 'index' is out of range, this method will return an empty
        string.  Callers should use XMLAttributes.getLength() to check the
        number of attributes contained in this object or
        XMLAttributes.hasAttribute()  to test for the existence of an
        attribute at a given position.

        Note: Note that although XMLAttributes provides operations that can
        manipulate attributes based on a numerical index, XML attributes are
        in fact unordered when they appear in files and data streams.  The
        XMLAttributes class provides some list-like facilities, but it is only
        for the convenience of callers.  (For example, it permits callers to
        loop across all attributes more easily.)  Users should keep in mind
        that the order in which attributes are stored in XMLAttributes objects
        has no real impact on the order in which the attributes are read or
        written from an XML file or data stream.

        See also getLength(), hasAttribute().

        """
        return _libsbml.XMLAttributes_getName(self, index)


    def getPrefix(self, index):
        """
        getPrefix(XMLAttributes self, int index) -> string


        Returns the namespace prefix of the nth attribute in this attribute
        set.

        Parameter 'index' is an integer, the position of the attribute whose
        namespace prefix is being sought.

        Returns the XML namespace prefix of the nth attribute.

        Note: If 'index' is out of range, this method will return an empty
        string.  Callers should use XMLAttributes.getLength() to check the
        number of attributes contained in this object or
        XMLAttributes.hasAttribute()  to test for the existence of an
        attribute at a given position.

        Note: Note that although XMLAttributes provides operations that can
        manipulate attributes based on a numerical index, XML attributes are
        in fact unordered when they appear in files and data streams.  The
        XMLAttributes class provides some list-like facilities, but it is only
        for the convenience of callers.  (For example, it permits callers to
        loop across all attributes more easily.)  Users should keep in mind
        that the order in which attributes are stored in XMLAttributes objects
        has no real impact on the order in which the attributes are read or
        written from an XML file or data stream.

        See also getLength(), hasAttribute().

        """
        return _libsbml.XMLAttributes_getPrefix(self, index)


    def getPrefixedName(self, index):
        """
        getPrefixedName(XMLAttributes self, int index) -> string


        Returns the prefix name of the nth attribute in this attribute set.

        Parameter 'index' is an integer, the position of the attribute whose
        prefixed name is being sought.

        Returns the prefixed name of the nth attribute.

        Note: If 'index' is out of range, this method will return an empty
        string.  Callers should use XMLAttributes.getLength() to check the
        number of attributes contained in this object or
        XMLAttributes.hasAttribute()  to test for the existence of an
        attribute at a given position.

        Note: Note that although XMLAttributes provides operations that can
        manipulate attributes based on a numerical index, XML attributes are
        in fact unordered when they appear in files and data streams.  The
        XMLAttributes class provides some list-like facilities, but it is only
        for the convenience of callers.  (For example, it permits callers to
        loop across all attributes more easily.)  Users should keep in mind
        that the order in which attributes are stored in XMLAttributes objects
        has no real impact on the order in which the attributes are read or
        written from an XML file or data stream.

        See also getLength(), hasAttribute().

        """
        return _libsbml.XMLAttributes_getPrefixedName(self, index)


    def getURI(self, index):
        """
        getURI(XMLAttributes self, int index) -> string


        Returns the XML namespace URI of the nth attribute in this attribute
        set.

        Parameter 'index' is an integer, the position of the attribute whose
        namespace URI is being sought.

        Returns the XML namespace URI of the nth attribute.

        Note: If 'index' is out of range, this method will return an empty
        string.  Callers should use XMLAttributes.getLength() to check the
        number of attributes contained in this object or
        XMLAttributes.hasAttribute()  to test for the existence of an
        attribute at a given position.

        Note: Note that although XMLAttributes provides operations that can
        manipulate attributes based on a numerical index, XML attributes are
        in fact unordered when they appear in files and data streams.  The
        XMLAttributes class provides some list-like facilities, but it is only
        for the convenience of callers.  (For example, it permits callers to
        loop across all attributes more easily.)  Users should keep in mind
        that the order in which attributes are stored in XMLAttributes objects
        has no real impact on the order in which the attributes are read or
        written from an XML file or data stream.

        See also getLength(), hasAttribute().

        """
        return _libsbml.XMLAttributes_getURI(self, index)


    def getValue(self, *args):
        """
        getValue(XMLAttributes self, int index) -> string
        getValue(XMLAttributes self, string name) -> string
        getValue(XMLAttributes self, string name, string uri) -> string
        getValue(XMLAttributes self, XMLTriple triple) -> string


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getValue(XMLTriple triple)

        Return the value of an attribute described by a given XMLTriple
        object.

        Parameter 'triple' is an XMLTriple describing the attribute whose
        value is being sought.

        Returns The attribute value as a string.

        Note: If an attribute with the properties given by 'triple' does not
        exist in this XMLAttributes object, this method will return an empty
        string.  Callers can use XMLAttributes.hasAttribute()  to test for an
        attribute's existence.

        See also hasAttribute(), hasAttribute().

        ______________________________________________________________________
        Method variant with the following signature:

            getValue(int index)

        Returns the value of the nth attribute in this list of attributes.

        Parameter 'index' is an integer, the position of the attribute whose
        value is being sought.

        Returns the XML value of the nth attribute.

        Note: If 'index' is out of range, this method will return an empty
        string.  Callers should use XMLAttributes.getLength() to check the
        number of attributes contained in this object or
        XMLAttributes.hasAttribute()  to test for the existence of an
        attribute at a given position.

        Note: Note that although XMLAttributes provides operations that can
        manipulate attributes based on a numerical index, XML attributes are
        in fact unordered when they appear in files and data streams.  The
        XMLAttributes class provides some list-like facilities, but it is only
        for the convenience of callers.  (For example, it permits callers to
        loop across all attributes more easily.)  Users should keep in mind
        that the order in which attributes are stored in XMLAttributes objects
        has no real impact on the order in which the attributes are read or
        written from an XML file or data stream.

        See also getLength(), hasAttribute().

        ______________________________________________________________________
        Method variant with the following signature:

            getValue(string name)

        Returns a named attribute's value.

        Parameter 'name' is a string, the unprefixed name of the attribute
        whose value is being sought.

        Returns The attribute value as a string.

        Note: If an attribute with the given local 'name' does not exist in
        this XMLAttributes object, this method will return an empty string.
        Callers can use XMLAttributes.hasAttribute()  to test for an
        attribute's existence.  This method also does not check the XML
        namespace of the named attribute.  Thus, if there are multiple
        attributes with the same local 'name' but different namespaces, this
        method will return the value of the first such attribute found.
        Callers should use the more specific methods XMLAttributes.getIndex()
        or XMLAttributes.getIndex()  to find attributes in particular
        namespaces.

        See also hasAttribute(), hasAttribute().

        ______________________________________________________________________
        Method variant with the following signature:

            getValue(string name, string uri)

        Returns a named attribute's value.

        Parameter 'name' is a string, the name of the attribute whose value is
        being sought. Parameter 'uri' is a string, the XML namespace URI of
        the attribute.

        Returns The attribute value as a string.

        Note: If an attribute with the given 'name' and namespace 'uri' does
        not exist in this XMLAttributes object, this method will return an
        empty string.  Callers can use XMLAttributes.hasAttribute()  to test
        for an attribute's existence.

        See also hasAttribute(), hasAttribute().

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


    def hasAttribute(self, *args):
        """
        hasAttribute(XMLAttributes self, int index) -> bool
        hasAttribute(XMLAttributes self, string name, string uri) -> bool
        hasAttribute(XMLAttributes self, string name) -> bool
        hasAttribute(XMLAttributes self, XMLTriple triple) -> bool


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            hasAttribute(string name, string uri='')

        Returns 'True' if an attribute with a given name and namespace URI
        exists.

        Parameter 'name' is a string, the unprefixed name of the attribute.
        Parameter 'uri' is a string, the XML namespace URI of the attribute.

        Returns 'True' if an attribute with the given local name and XML
        namespace URI exists in this XMLAttributes object, 'False' otherwise.

        See also add(), add().

        ______________________________________________________________________
        Method variant with the following signature:

            hasAttribute(XMLTriple triple)

        Returns 'True' if an attribute with the given properties exists.

        Parameter 'triple' is an XMLTriple describing the attribute to be
        tested.

        Returns 'True' if an attribute with the given XML triple exists in
        this XMLAttributes object, 'False' otherwise.

        See also add(), add().

        ______________________________________________________________________
        Method variant with the following signature:

            hasAttribute(int index)

        Returns 'True' if an attribute exists at a given index.

        Parameter 'index' is an integer, the position of the attribute to be
        tested.

        Returns 'True' if an attribute with the given index exists in this
        XMLAttributes object, 'False' otherwise.

        Note: Note that although XMLAttributes provides operations that can
        manipulate attributes based on a numerical index, XML attributes are
        in fact unordered when they appear in files and data streams.  The
        XMLAttributes class provides some list-like facilities, but it is only
        for the convenience of callers.  (For example, it permits callers to
        loop across all attributes more easily.)  Users should keep in mind
        that the order in which attributes are stored in XMLAttributes objects
        has no real impact on the order in which the attributes are read or
        written from an XML file or data stream.

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


    def isEmpty(self):
        """
        isEmpty(XMLAttributes self) -> bool


        Returns 'True' if this list of attributes is empty.

        Returns 'True' if this XMLAttributes object is empty, 'False'
        otherwise.

        """
        return _libsbml.XMLAttributes_isEmpty(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

XMLAttributes_swigregister = _libsbml.XMLAttributes_swigregister
XMLAttributes_swigregister(XMLAttributes)

class XMLNamespaces(_object):
    """

    An XML Namespace.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    This class serves to organize functionality for tracking XML
    namespaces in a document or data stream.  The namespace declarations
    are stored as a list of pairs of XML namespace URIs and prefix
    strings.  These correspond to the parts of a namespace declaration on
    an XML element. For example, in the following XML fragment,

      <annotation>
          <mysim:nodecolors xmlns:mysim='urn:lsid:mysim.org'
               mysim:bgcolor='green' mysim:fgcolor='white'/>
      </annotation>

    there is one namespace declaration.  Its URI is urn:lsid:mysim.org and
    its prefix is mysim. This pair could be stored as one item in an
    XMLNamespaces list.

    XMLNamespaces provides various methods for manipulating the list of
    prefix-URI pairs.  Individual namespaces stored in a given
    XMLNamespace object instance can be retrieved based on their index
    using XMLNamespaces.getPrefix(), or by their characteristics such as
    their URI or position in the list.

    """

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, XMLNamespaces, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, XMLNamespaces, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_XMLNamespaces
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(XMLNamespaces self) -> XMLNamespaces
        __init__(XMLNamespaces self, XMLNamespaces orig) -> XMLNamespaces


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            XMLNamespaces()

        Creates a new empty list of XML namespace declarations.

        ______________________________________________________________________
        Method variant with the following signature:

            XMLNamespaces(XMLNamespaces orig)

        Copy constructor; creates a copy of this XMLNamespaces list.

        Parameter 'orig' is the XMLNamespaces object to copy.

        """
        this = _libsbml.new_XMLNamespaces(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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


        Creates and returns a deep copy of this XMLNamespaces object.

        Returns the (deep) copy of this XMLNamespaces object.

        """
        return _libsbml.XMLNamespaces_clone(self)


    def add(self, *args):
        """
        add(XMLNamespaces self, string uri, string prefix) -> int
        add(XMLNamespaces self, string uri) -> int


        Appends an XML namespace prefix and URI pair to this list of namespace
        declarations.

        An XMLNamespaces object stores a list of pairs of namespaces and their
        prefixes.  If there is an XML namespace with the given 'uri' prefix in
        this list, then its corresponding URI will be overwritten by the new
        'uri' unless the uri represents the core sbml namespace. Calling
        programs could use one of the other XMLNamespaces methods, such as
        XMLNamespaces.hasPrefix() and  XMLNamespaces.hasURI() to inquire
        whether a given prefix and/or URI is already present in this
        XMLNamespaces object. If the 'uri' represents the sbml namespaces then
        it will not be overwritten, as this has potentially serious
        consequences. If it is necessary to replace the sbml namespace the
        namespace should be removed prior to adding the new namespace.

        Parameter 'uri' is a string, the uri for the namespace. Parameter
        'prefix' is a string, the prefix for the namespace.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_OPERATION_FAILED

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

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


    def remove(self, *args):
        """
        remove(XMLNamespaces self, int index) -> int
        remove(XMLNamespaces self, string prefix) -> int


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(int index)

        Removes an XML Namespace stored in the given position of this list.

        Parameter 'index' is an integer, position of the namespace to remove.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INDEX_EXCEEDS_SIZE

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string prefix)

        Removes an XML Namespace with the given prefix.

        Parameter 'prefix' is a string, prefix of the required namespace.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INDEX_EXCEEDS_SIZE

        See also remove().

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


    def clear(self):
        """
        clear(XMLNamespaces self) -> int


        Clears (deletes) all XML namespace declarations in this XMLNamespaces
        object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also remove().

        """
        return _libsbml.XMLNamespaces_clear(self)


    def getIndex(self, uri):
        """
        getIndex(XMLNamespaces self, string uri) -> int


        Look up the index of an XML namespace declaration by URI.

        An XMLNamespaces object stores a list of pairs of namespaces and their
        prefixes.  If this XMLNamespaces object contains a pair with the given
        URI 'uri', this method returns its index in the list.

        Parameter 'uri' is a string, the URI of the sought-after namespace.

        Returns the index of the given declaration, or -1 if not present.

        """
        return _libsbml.XMLNamespaces_getIndex(self, uri)


    def containsUri(self, uri):
        """
        containsUri(XMLNamespaces self, string uri) -> bool


        Tests whether the given uri is contained in this set of namespaces.

        """
        return _libsbml.XMLNamespaces_containsUri(self, uri)


    def getIndexByPrefix(self, prefix):
        """
        getIndexByPrefix(XMLNamespaces self, string prefix) -> int


        Look up the index of an XML namespace declaration by 'prefix'.

        An XMLNamespaces object stores a list of pairs of namespaces and their
        prefixes.  If this XMLNamespaces object contains a pair with the given
        prefix 'prefix', this method returns its index in the list.

        Parameter 'prefix' is a string, the prefix string of the sought-after
        namespace.

        Returns the index of the given declaration, or -1 if not present.

        """
        return _libsbml.XMLNamespaces_getIndexByPrefix(self, prefix)


    def getLength(self):
        """
        getLength(XMLNamespaces self) -> int


        Returns the total number of URI-and-prefix pairs stored in this
        particular XMLNamespaces instance.

        Returns the number of namespaces in this list.

        """
        return _libsbml.XMLNamespaces_getLength(self)


    def getNumNamespaces(self):
        """
        getNumNamespaces(XMLNamespaces self) -> int


        Returns the total number of URI-and-prefix pairs stored in this
        particular XMLNamespaces instance.

        Returns the number of namespaces in this list.

        This function is an alias for getLength introduced for consistency
        with other XML classes.

        """
        return _libsbml.XMLNamespaces_getNumNamespaces(self)


    def getPrefix(self, *args):
        """
        getPrefix(XMLNamespaces self, int index) -> string
        getPrefix(XMLNamespaces self, string uri) -> string


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getPrefix(int index)

        Look up the prefix of an XML namespace declaration by its position.

        An XMLNamespaces object stores a list of pairs of namespaces and their
        prefixes.  This method returns the prefix of the nth element in that
        list (if it exists).  Callers should use XMLAttributes.getLength()
        first to find out how many namespaces are stored in the list.

        Parameter 'index' is an integer, position of the sought-after prefix.

        Returns the prefix of an XML namespace declaration in this list (by
        position), or an empty string if the 'index' is out of range.

        See also getLength().

        ______________________________________________________________________
        Method variant with the following signature:

            getPrefix(string uri)

        Look up the prefix of an XML namespace declaration by its URI.

        An XMLNamespaces object stores a list of pairs of namespaces and their
        prefixes.  This method returns the prefix for a pair that has the
        given 'uri'.

        Parameter 'uri' is a string, the URI of the prefix being sought.

        Returns the prefix of an XML namespace declaration given its URI, or
        an empty string if no such 'uri' exists in this XMLNamespaces object.

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


    def getURI(self, *args):
        """
        getURI(XMLNamespaces self, int index) -> string
        getURI(XMLNamespaces self, string prefix) -> string
        getURI(XMLNamespaces self) -> string


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getURI(string prefix = '')

        Look up the URI of an XML namespace declaration by its prefix.

        An XMLNamespaces object stores a list of pairs of namespaces and their
        prefixes.  This method returns the namespace URI for a pair that has
        the given 'prefix'.

        Parameter 'prefix' is a string, the prefix of the required URI.

        Returns the URI of an XML namespace declaration having the given
        'prefix', or an empty string if no such prefix-and-URI pair exists in
        this XMLNamespaces object.

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        See also getURI().

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            getURI(int index)

        Look up the URI of an XML namespace declaration by its position.

        An XMLNamespaces object stores a list of pairs of namespaces and their
        prefixes.  This method returns the URI of the nth element in that list
        (if it exists).  Callers should use XMLAttributes.getLength() first to
        find out how many namespaces are stored in the list.

        Parameter 'index' is an integer, position of the required URI.

        Returns the URI of an XML namespace declaration in this list (by
        position), or an empty string if the 'index' is out of range.

        See also getLength().

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


    def isEmpty(self):
        """
        isEmpty(XMLNamespaces self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        XMLNamespaces list is empty.

        Returns 'True' if this XMLNamespaces list is empty, 'False' otherwise.

        """
        return _libsbml.XMLNamespaces_isEmpty(self)


    def hasURI(self, uri):
        """
        hasURI(XMLNamespaces self, string uri) -> bool


        Predicate returning 'True' or 'False' depending on whether an XML
        Namespace with the given URI is contained in this XMLNamespaces list.

        Parameter 'uri' is a string, the uri for the namespace.

        Returns 'True' if an XML Namespace with the given URI is contained in
        this XMLNamespaces list, 'False' otherwise.

        """
        return _libsbml.XMLNamespaces_hasURI(self, uri)


    def hasPrefix(self, prefix):
        """
        hasPrefix(XMLNamespaces self, string prefix) -> bool


        Predicate returning 'True' or 'False' depending on whether an XML
        Namespace with the given prefix is contained in this XMLNamespaces
        list.

        Parameter 'prefix' is a string, the prefix for the namespace.

        Returns 'True' if an XML Namespace with the given URI is contained in
        this XMLNamespaces list, 'False' otherwise.

        """
        return _libsbml.XMLNamespaces_hasPrefix(self, prefix)


    def hasNS(self, uri, prefix):
        """
        hasNS(XMLNamespaces self, string uri, string prefix) -> bool


        Predicate returning 'True' or 'False' depending on whether an XML
        Namespace with the given URI and prefix pair is contained in this
        XMLNamespaces list.

        Parameter 'uri' is a string, the URI for the namespace. Parameter
        'prefix' is a string, the prefix for the namespace.

        Returns 'True' if an XML Namespace with the given uri/prefix pair is
        contained in this XMLNamespaces list, 'False' otherwise.

        """
        return _libsbml.XMLNamespaces_hasNS(self, uri, prefix)


    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

XMLNamespaces_swigregister = _libsbml.XMLNamespaces_swigregister
XMLNamespaces_swigregister(XMLNamespaces)

class XMLToken(_object):
    """

    A token in an XML stream.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    The libSBML XML parser interface can read an XML file or data stream
    and convert the contents into tokens.  The tokens represent items in
    the XML stream, either XML elements (start or end tags) or text that
    appears as content inside an element.  The XMLToken class is libSBML's
    low-level representation of these entities.

    Each XMLToken has the following information associated with it: <ol>

    * Qualified name: every XML element or XML attribute has a name
    (e.g., for the element <mytag>, the name is 'mytag'), but this name
    may be qualified with a namespace (e.g., it may appear as
    <someNamespace:mytag> in the input).  An XMLToken stores the name of a
    token, along with any namespace qualification present, through the use
    of an XMLTriple object.  This object stores the bare name of the
    element, its XML namespace prefix (if any), and the XML namespace with
    which that prefix is associated.

    * Namespaces: An XML token can have one or more XML namespaces
    associated with it.  These namespaces may be specified explicitly on
    the element or inherited from parent elements.  In libSBML, a list of
    namespaces is stored in an XMLNamespaces object.  An XMLToken
    possesses a field for storing an XMLNamespaces object.

    * Attributes: XML elements can have attributes associated with
    them, and these attributes can have values assigned to them.  The set
    of attribute-value pairs is stored in an XMLAttributes object stored
    in an XMLToken object.  (Note: only elements can have attributes --
    text blocks cannot have them in XML.)

    * Line number: the line number in the input where the token
    appears.

    * Column number: the column number in the input where the token
    appears. </ol>

    The XMLToken class serves as base class for XMLNode.  XML lends itself
    to a tree-structured representation, and in libSBML, the nodes in an
    XML document tree are XMLNode objects.  Most higher-level libSBML
    classes and methods that offer XML-level functionality (such as the
    methods on SBase for interacting with annotations) work with XMLNode
    objects rather than XMLToken objects directly.

    See also XMLNode, XMLTriple, XMLAttributes, XMLNamespaces.

    """

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, XMLToken, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, XMLToken, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_XMLToken
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(XMLToken self) -> XMLToken
        __init__(XMLToken self, XMLTriple triple, XMLAttributes attributes, XMLNamespaces namespaces, unsigned int const line=0, unsigned int const column=0) -> XMLToken
        __init__(XMLToken self, XMLTriple triple, XMLAttributes attributes, XMLNamespaces namespaces, unsigned int const line=0) -> XMLToken
        __init__(XMLToken self, XMLTriple triple, XMLAttributes attributes, XMLNamespaces namespaces) -> XMLToken
        __init__(XMLToken self, XMLTriple triple, XMLAttributes attributes, unsigned int const line=0, unsigned int const column=0) -> XMLToken
        __init__(XMLToken self, XMLTriple triple, XMLAttributes attributes, unsigned int const line=0) -> XMLToken
        __init__(XMLToken self, XMLTriple triple, XMLAttributes attributes) -> XMLToken
        __init__(XMLToken self, XMLTriple triple, unsigned int const line=0, unsigned int const column=0) -> XMLToken
        __init__(XMLToken self, XMLTriple triple, unsigned int const line=0) -> XMLToken
        __init__(XMLToken self, XMLTriple triple) -> XMLToken
        __init__(XMLToken self, string chars, unsigned int const line=0, unsigned int const column=0) -> XMLToken
        __init__(XMLToken self, string chars, unsigned int const line=0) -> XMLToken
        __init__(XMLToken self, string chars) -> XMLToken
        __init__(XMLToken self, XMLToken orig) -> XMLToken


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            XMLToken()

        Creates a new empty XMLToken object.

        ______________________________________________________________________
        Method variant with the following signature:

            XMLToken(XMLToken orig)

        Copy constructor; creates a copy of this XMLToken object.

        Parameter 'orig' is the XMLToken object to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            XMLToken(  XMLTriple      triple , XMLAttributes  attributes
        ,  long    line   = 0 ,  long    column = 0 )

        Creates an XML start element with attributes.

        Parameter 'triple' is an XMLTriple object describing the start tag.

        Parameter 'attributes' is XMLAttributes, the attributes to set on the
        element to be created.

        Parameter 'line' is a long integer, the line number to associate with
        the token (default = 0).

        Parameter 'column' is a long integer, the column number to associate
        with the token (default = 0).

        The XML namespace component of this XMLToken object will be left
        empty. See the other variants of the XMLToken constructors for
        versions that take namespace arguments.

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            XMLToken(  XMLTriple    triple ,  long  line   = 0 ,  long
        column = 0 )

        Creates an XML end element.

        Parameter 'triple' is an XMLTriple object describing the end tag.

        Parameter 'line' is a long integer, the line number to associate with
        the token (default = 0).

        Parameter 'column' is a long integer, the column number to associate
        with the token (default = 0).

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            XMLToken(  XMLTriple      triple , XMLAttributes  attributes
        , XMLNamespaces  namespaces ,  long    line   = 0 ,  long    column =
        0 )

        Creates an XML start element with attributes and namespace
        declarations.

        Parameter 'triple' is an XMLTriple object describing the start tag.

        Parameter 'attributes' is XMLAttributes, the attributes to set on the
        element to be created.

        Parameter 'namespaces' is XMLNamespaces, the namespaces to set on the
        element to be created.

        Parameter 'line' is a long integer, the line number to associate with
        the token (default = 0).

        Parameter 'column' is a long integer, the column number to associate
        with the token (default = 0).

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            XMLToken(  string  chars ,  long  line   = 0 ,  long  column
        = 0 )

        Creates a text object.

        Parameter 'chars' is a string, the text to be added to the XMLToken
        object.

        Parameter 'line' is a long integer, the line number to associate with
        the token (default = 0).

        Parameter 'column' is a long integer, the column number to associate
        with the token (default = 0).

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        this = _libsbml.new_XMLToken(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(XMLToken self) -> XMLToken


        Creates and returns a deep copy of this XMLToken object.

        Returns the (deep) copy of this XMLToken object.

        """
        return _libsbml.XMLToken_clone(self)


    def getAttributes(self):
        """
        getAttributes(XMLToken self) -> XMLAttributes


        Returns the attributes of the XML element represented by this token.

        Returns the attributes of this XML element, stored in an XMLAttributes
        object.

        """
        return _libsbml.XMLToken_getAttributes(self)


    def setAttributes(self, attributes):
        """
        setAttributes(XMLToken self, XMLAttributes attributes) -> int


        Sets the attributes on the XML element represented by this token.

        This operation only makes sense for XML start elements.  This method
        will return LIBSBML_INVALID_XML_OPERATION if this XMLToken object is
        not an XML start element.

        Parameter 'attributes' is an XMLAttributes object to be assigned to
        this XMLToken object, thereby setting the XML attributes associated
        with this token.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_XML_OPERATION

        * LIBSBML_INVALID_OBJECT

        Note: This function replaces any existing XMLAttributes object on this
        XMLToken object with the one given by 'attributes'.

        """
        return _libsbml.XMLToken_setAttributes(self, attributes)


    def addAttr(self, *args):
        """
        addAttr(XMLToken self, string name, string value, string namespaceURI, string prefix) -> int
        addAttr(XMLToken self, string name, string value, string namespaceURI) -> int
        addAttr(XMLToken self, string name, string value) -> int
        addAttr(XMLToken self, XMLTriple triple, string value) -> int


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            addAttr(  string name , string value , string namespaceURI =
        '' , string prefix = '')

        Adds an attribute to the XML element represented by this token.

        This operation only makes sense for XML start elements.  This method
        will return LIBSBML_INVALID_XML_OPERATION if this XMLToken object is
        not an XML start element.

        Parameter 'name' is a string, the so-called 'local part' of the
        attribute name; that is, the attribute name without any namespace
        qualifier or prefix.

        Parameter 'value' is a string, the value assigned to the attribute.

        Parameter 'namespaceURI' is a string, the XML namespace URI of the
        attribute.

        Parameter 'prefix' is a string, the prefix for the XML namespace.

        Recall that in XML, the complete form of an attribute on an XML
        element is the following: <center> prefix:name='value' </center> The
        name part is the name of the attribute, the 'value' part is the value
        assigned to the attribute (and it is always a quoted string), and the
        prefix part is an optional XML namespace prefix.  Internally in
        libSBML, this data is stored in an XMLAttributes object associated
        with this XMLToken.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_INVALID_XML_OPERATION

        Note: If an attribute with the same name and XML namespace URI already
        exists on this XMLToken object, then the previous value will be
        replaced with the new value provided to this method.

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            addAttr( XMLTriple triple, string value)

        Adds an attribute to the XML element represented by this token.

        This operation only makes sense for XML start elements.  This method
        will return LIBSBML_INVALID_XML_OPERATION if this XMLToken object is
        not an XML start element.

        Parameter 'triple' is an XMLTriple object defining the attribute, its
        value, and optionally its XML namespace (if any is provided).

        Parameter 'value' is a string, the value assigned to the attribute.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_INVALID_XML_OPERATION

        Note: If an attribute with the same name and XML namespace URI already
        exists on this XMLToken object, then the previous value will be
        replaced with the new value provided to this method.

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


    def removeAttr(self, *args):
        """
        removeAttr(XMLToken self, int n) -> int
        removeAttr(XMLToken self, string name, string uri) -> int
        removeAttr(XMLToken self, string name) -> int
        removeAttr(XMLToken self, XMLTriple triple) -> int


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeAttr(string name, string uri = '')

        Removes an attribute from the XML element represented by this token.

        This operation only makes sense for XML start elements.  This method
        will return LIBSBML_INVALID_XML_OPERATION if this XMLToken object is
        not an XML start element.

        Parameter 'name' is a string, the name of the attribute to be removed.
        Parameter 'uri' is a string, the XML namespace URI of the attribute to
        be removed.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_XML_OPERATION

        * LIBSBML_INDEX_EXCEEDS_SIZE

        The value LIBSBML_INDEX_EXCEEDS_SIZE is returned if there is no
        attribute on this element with the given 'name' (and 'uri' if
        specified).

        See also hasAttr().

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            removeAttr(int n)

        Removes the nth attribute from the XML element represented by this
        token.

        This operation only makes sense for XML start elements.  This method
        will return LIBSBML_INVALID_XML_OPERATION if this XMLToken object is
        not an XML start element.

        Parameter 'n' is an integer the index of the resource to be deleted.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_XML_OPERATION

        * LIBSBML_INDEX_EXCEEDS_SIZE

        The value LIBSBML_INDEX_EXCEEDS_SIZE is returned if there is no
        attribute on this element at the given index 'n'.

        See also getAttrIndex(), getAttrIndex(), getAttributesLength().

        ______________________________________________________________________
        Method variant with the following signature:

            removeAttr(XMLTriple triple)

        Removes an attribute from the XML element represented by this token.

        This operation only makes sense for XML start elements.  This method
        will return LIBSBML_INVALID_XML_OPERATION if this XMLToken object is
        not an XML start element.

        Parameter 'triple' is an XMLTriple describing the attribute to be
        removed.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_XML_OPERATION

        * LIBSBML_INDEX_EXCEEDS_SIZE

        The value LIBSBML_INDEX_EXCEEDS_SIZE is returned if there is no
        attribute on this element matching the properties of the given
        'triple'.

        See also hasAttr().

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


    def clearAttributes(self):
        """
        clearAttributes(XMLToken self) -> int


        Removes all attributes of this XMLToken object.

        This operation only makes sense for XML start elements.  This method
        will return LIBSBML_INVALID_XML_OPERATION if this XMLToken object is
        not an XML start element.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_XML_OPERATION

        """
        return _libsbml.XMLToken_clearAttributes(self)


    def getAttrIndex(self, *args):
        """
        getAttrIndex(XMLToken self, string name, string uri) -> int
        getAttrIndex(XMLToken self, string name) -> int
        getAttrIndex(XMLToken self, XMLTriple triple) -> int


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getAttrIndex(string name, string uri='')

        Returns the index of the attribute with the given name and namespace
        URI.

        Parameter 'name' is a string, the name of the attribute. Parameter
        'uri' is a string, the namespace URI of the attribute.

        Returns the index of an attribute with the given local name and
        namespace URI, or -1 if it is not present on this token.

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        ______________________________________________________________________
        Method variant with the following signature:

            getAttrIndex(XMLTriple triple)

        Returns the index of the attribute defined by the given XMLTriple
        object.

        Parameter 'triple' is the XMLTriple object that defines the attribute
        whose index is being sought.

        Returns the index of an attribute with the given XMLTriple object, or
        -1 if no such attribute is present on this token.

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


    def getAttributesLength(self):
        """
        getAttributesLength(XMLToken self) -> int


        Returns the number of attributes on this XMLToken object.

        Returns the number of attributes possessed by this token.

        See also hasAttr().

        """
        return _libsbml.XMLToken_getAttributesLength(self)


    def getAttrName(self, index):
        """
        getAttrName(XMLToken self, int index) -> string


        Returns the name of the nth attribute in this token's list of
        attributes.

        Parameter 'index' is an integer, the position of the attribute whose
        name is being sought.

        Returns the name of the attribute located at position 'n' in the list
        of attributes possessed by this XMLToken object.

        Note: If 'index' is out of range, this method will return an empty
        string.  XMLToken.hasAttr() can be used to test for an attribute's
        existence explicitly, and XMLToken.getAttributesLength() can be used
        to find out the number of attributes possessed by this token.

        See also hasAttr(), getAttributesLength().

        """
        return _libsbml.XMLToken_getAttrName(self, index)


    def getAttrPrefix(self, index):
        """
        getAttrPrefix(XMLToken self, int index) -> string


        Returns the prefix of the nth attribute in this token's list of
        attributes.

        Parameter 'index' is an integer, the position of the attribute whose
        prefix is being sought.

        Returns the XML namespace prefix of the attribute located at position
        'n' in the list of attributes possessed by this XMLToken object.

        Note: If 'index' is out of range, this method will return an empty
        string.  XMLToken.hasAttr() can be used to test for an attribute's
        existence explicitly, and XMLToken.getAttributesLength() can be used
        to find out the number of attributes possessed by this token.

        See also hasAttr(), getAttributesLength().

        """
        return _libsbml.XMLToken_getAttrPrefix(self, index)


    def getAttrPrefixedName(self, index):
        """
        getAttrPrefixedName(XMLToken self, int index) -> string


        Returns the prefixed name of the nth attribute in this token's list of
        attributes.

        In this context, prefixed name means the name of the attribute
        prefixed with the XML namespace prefix assigned to the attribute.
        This will be a string of the form prefix:name.

        Parameter 'index' is an integer, the position of the attribute whose
        prefixed name is being sought.

        Returns the prefixed name of the attribute located at position 'n' in
        the list of attributes possessed by this XMLToken object.

        Note: If 'index' is out of range, this method will return an empty
        string.  XMLToken.hasAttr() can be used to test for an attribute's
        existence explicitly, and XMLToken.getAttributesLength() can be used
        to find out the number of attributes possessed by this token.

        """
        return _libsbml.XMLToken_getAttrPrefixedName(self, index)


    def getAttrURI(self, index):
        """
        getAttrURI(XMLToken self, int index) -> string


        Returns the XML namespace URI of the nth attribute in this token's
        list of attributes.

        Parameter 'index' is an integer, the position of the attribute whose
        namespace URI is being sought.

        Returns the XML namespace URI of the attribute located at position 'n'
        in the list of attributes possessed by this XMLToken object.

        Note: If 'index' is out of range, this method will return an empty
        string.  XMLToken.hasAttr() can be used to test for an attribute's
        existence explicitly, and XMLToken.getAttributesLength() can be used
        to find out the number of attributes possessed by this token.

        """
        return _libsbml.XMLToken_getAttrURI(self, index)


    def getAttrValue(self, *args):
        """
        getAttrValue(XMLToken self, int index) -> string
        getAttrValue(XMLToken self, string name, string uri) -> string
        getAttrValue(XMLToken self, string name) -> string
        getAttrValue(XMLToken self, XMLTriple triple) -> string


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getAttrValue(string name, string uri='')

        Returns the value of the attribute with a given name and XML namespace
        URI.

        Parameter 'name' is a string, the name of the attribute whose value is
        being sought.

        Parameter 'uri' is a string, the XML namespace URI of the attribute.

        Returns The value of the attribute, as a string.

        Note: If an attribute with the given 'name' and 'uri' does not exist
        on this token object, this method will return an empty string.
        XMLToken.hasAttr() can be used to test explicitly for the presence of
        an attribute with a given name and namespace.

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        ______________________________________________________________________
        Method variant with the following signature:

            getAttrValue(XMLTriple triple)

        Returns the value of the attribute specified by a given XMLTriple
        object.

        Parameter 'triple' is an XMLTriple describing the attribute whose
        value is being sought.

        Returns The value of the attribute, as a string.

        Note: If an attribute defined by the given 'triple' does not exist on
        this token object, this method will return an empty string.
        XMLToken.hasAttr() can be used to test explicitly for the existence of
        an attribute with the properties of a given triple.

        ______________________________________________________________________
        Method variant with the following signature:

            getAttrValue(int index)

        Returns the value of the nth attribute in this token's list of
        attributes.

        Parameter 'index' is an integer, the position of the attribute whose
        value is required.

        Returns the value of the attribute located at position 'n' in the list
        of attributes possessed by this XMLToken object.

        Note: If 'index' is out of range, this method will return an empty
        string.  XMLToken.hasAttr() can be used to test for an attribute's
        existence explicitly, and XMLToken.getAttributesLength() can be used
        to find out the number of attributes possessed by this token.

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


    def hasAttr(self, *args):
        """
        hasAttr(XMLToken self, int index) -> bool
        hasAttr(XMLToken self, string name, string uri) -> bool
        hasAttr(XMLToken self, string name) -> bool
        hasAttr(XMLToken self, XMLTriple triple) -> bool


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            hasAttr(string name, string uri='')

        Returns 'True' if an attribute with a given name and namespace URI
        exists.

        Parameter 'name' is a string, the name of the attribute being sought.

        Parameter 'uri' is a string, the XML namespace URI of the attribute
        being sought.

        Returns 'True' if an attribute with the given local name and namespace
        URI exists in the list of attributes on this token object, 'False'
        otherwise.

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        ______________________________________________________________________
        Method variant with the following signature:

            hasAttr(XMLTriple triple)

        Returns 'True' if an attribute defined by a given XMLTriple object
        exists.

        Parameter 'triple' is an XMLTriple object describing the attribute
        being sought.

        Returns 'True' if an attribute matching the properties of the given
        XMLTriple object exists in the list of attributes on this token,
        'False' otherwise.

        ______________________________________________________________________
        Method variant with the following signature:

            hasAttr(int index)

        Returns 'True' if an attribute with the given index exists.

        Parameter 'index' is an integer, the position of the attribute.

        Returns 'True' if this token object possesses an attribute with the
        given index, 'False' otherwise.

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


    def isAttributesEmpty(self):
        """
        isAttributesEmpty(XMLToken self) -> bool


        Returns 'True' if this token has no attributes.

        Returns 'True' if the list of attributes on XMLToken object is empty,
        'False' otherwise.

        """
        return _libsbml.XMLToken_isAttributesEmpty(self)


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


        Returns the XML namespaces declared for this token.

        Returns the XML namespace declarations for this XML element.

        """
        return _libsbml.XMLToken_getNamespaces(self)


    def setNamespaces(self, namespaces):
        """
        setNamespaces(XMLToken self, XMLNamespaces namespaces) -> int


        Sets the XML namespaces on this XML element.

        This operation only makes sense for XML start elements.  This method
        will return LIBSBML_INVALID_XML_OPERATION if this XMLToken object is
        not an XML start element.

        Parameter 'namespaces' is the XMLNamespaces object to be assigned to
        this XMLToken object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_XML_OPERATION

        * LIBSBML_INVALID_OBJECT

        Note: This function replaces any existing XMLNamespaces object on this
        XMLToken object with the new one given by 'namespaces'.

        """
        return _libsbml.XMLToken_setNamespaces(self, namespaces)


    def addNamespace(self, *args):
        """
        addNamespace(XMLToken self, string uri, string prefix) -> int
        addNamespace(XMLToken self, string uri) -> int


        Appends an XML namespace declaration to this token.

        The namespace added will be defined by the given XML namespace URI and
        an optional prefix.  If this XMLToken object already possesses an XML
        namespace declaration with the given 'prefix', then the existing XML
        namespace URI will be overwritten by the new one given by 'uri'.

        This operation only makes sense for XML start elements.  This method
        will return LIBSBML_INVALID_XML_OPERATION if this XMLToken object is
        not an XML start element.

        Parameter 'uri' is a string, the XML namespace URI for the namespace.

        Parameter 'prefix' is a string, the namespace prefix to use.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_XML_OPERATION

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

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


    def removeNamespace(self, *args):
        """
        removeNamespace(XMLToken self, int index) -> int
        removeNamespace(XMLToken self, string prefix) -> int


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeNamespace(int index)

        Removes the nth XML namespace declaration.

        This operation only makes sense for XML start elements.  This method
        will return LIBSBML_INVALID_XML_OPERATION if this XMLToken object is
        not an XML start element.

        Parameter 'index' is an integer, the position of the namespace to be
        removed. The position in this context refers to the position of the
        namespace in the XMLNamespaces object stored in this XMLToken object.
        Callers can use one of the getNamespace___() methods to find the index
        number of a given namespace.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_XML_OPERATION

        * LIBSBML_INDEX_EXCEEDS_SIZE

        See also getNamespaceIndex(), getNamespaceIndexByPrefix(),
        getNamespacesLength().

        ______________________________________________________________________
        Method variant with the following signature:

            removeNamespace(string prefix)

        Removes an XML namespace declaration having a given prefix.

        This operation only makes sense for XML start elements.  This method
        will return LIBSBML_INVALID_XML_OPERATION if this XMLToken object is
        not an XML start element.

        Parameter 'prefix' is a string, the prefix of the namespace to be
        removed.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_XML_OPERATION

        * LIBSBML_INDEX_EXCEEDS_SIZE

        The value LIBSBML_INDEX_EXCEEDS_SIZE is returned if there is no
        namespace with the given 'prefix' on this element.

        See also getNamespaceIndexByPrefix().

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


    def clearNamespaces(self):
        """
        clearNamespaces(XMLToken self) -> int


        Removes all XML namespace declarations from this token.

        This operation only makes sense for XML start elements.  This method
        will return LIBSBML_INVALID_XML_OPERATION if this XMLToken object is
        not an XML start element.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_XML_OPERATION

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.XMLToken_clearNamespaces(self)


    def getNamespaceIndex(self, uri):
        """
        getNamespaceIndex(XMLToken self, string uri) -> int


        Returns the index of an XML namespace declaration based on its URI.

        Parameter 'uri' is a string, the XML namespace URI of the sought-after
        namespace.

        Returns the index of the given declaration, or -1 if no such namespace
        URI is present on this XMLToken object.

        """
        return _libsbml.XMLToken_getNamespaceIndex(self, uri)


    def getNamespaceIndexByPrefix(self, prefix):
        """
        getNamespaceIndexByPrefix(XMLToken self, string prefix) -> int


        Returns the index of an XML namespace declaration based on its prefix.

        Parameter 'prefix' is a string, the prefix of the sought-after XML
        namespace.

        Returns the index of the given declaration, or -1 if no such namespace
        URI is present on this XMLToken object.

        """
        return _libsbml.XMLToken_getNamespaceIndexByPrefix(self, prefix)


    def getNamespacesLength(self):
        """
        getNamespacesLength(XMLToken self) -> int


        Returns the number of XML namespaces declared on this token.

        Returns the number of XML namespaces stored in the XMLNamespaces
        object of this XMLToken object.

        """
        return _libsbml.XMLToken_getNamespacesLength(self)


    def getNamespacePrefix(self, *args):
        """
        getNamespacePrefix(XMLToken self, int index) -> string
        getNamespacePrefix(XMLToken self, string uri) -> string


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getNamespacePrefix(int index)

        Returns the prefix of the nth XML namespace declaration.

        Parameter 'index' is an integer, position of the required prefix.

        Returns the prefix of an XML namespace declaration in the
        XMLNamespaces (by position).

        Note: If 'index' is out of range, this method will return an empty
        string.  XMLToken.getNamespacesLength() can be used to find out how
        many namespaces are defined on this XMLToken object.

        See also getNamespacesLength().

        ______________________________________________________________________
        Method variant with the following signature:

            getNamespacePrefix(string uri)

        Returns the prefix associated with a given XML namespace URI on this
        token.

        Parameter 'uri' is a string, the URI of the namespace whose prefix is
        being sought.

        Returns the prefix of an XML namespace declaration on this XMLToken
        object.

        Note: If there is no XML namespace with the given 'uri' declared on
        this XMLToken object, this method will return an empty string.

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


    def getNamespaceURI(self, *args):
        """
        getNamespaceURI(XMLToken self, int index) -> string
        getNamespaceURI(XMLToken self, string prefix) -> string
        getNamespaceURI(XMLToken self) -> string


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getNamespaceURI(string prefix = '')

        Returns the URI of an XML namespace with a given prefix.

        Parameter 'prefix' is a string, the prefix of the sought-after XML
        namespace URI.

        Returns the URI of an XML namespace declaration given its prefix.

        Note: If there is no XML namespace with the given 'prefix' stored in
        the XMLNamespaces object of this XMLToken object, this method will
        return an empty string.

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            getNamespaceURI(int index)

        Returns the URI of the nth XML namespace declared on this token.

        Parameter 'index' is an integer, the position of the sought-after XML
        namespace URI.

        Returns the URI of the nth XML namespace stored in the XMLNamespaces
        object in this XMLToken object.

        Note: If 'index' is out of range, this method will return an empty
        string.

        See also getNamespacesLength().

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


    def isNamespacesEmpty(self):
        """
        isNamespacesEmpty(XMLToken self) -> bool


        Returns 'True' if there are no namespaces declared on this token.

        Returns 'True' if the XMLNamespaces object stored in this XMLToken
        token is empty, 'False' otherwise.

        """
        return _libsbml.XMLToken_isNamespacesEmpty(self)


    def hasNamespaceURI(self, uri):
        """
        hasNamespaceURI(XMLToken self, string uri) -> bool


        Returns 'True' if this token has an XML namespace with a given URI.

        Parameter 'uri' is a string, the URI of the XML namespace.

        Returns 'True' if an XML namespace with the given URI is contained in
        the XMLNamespaces object of this XMLToken object, 'False' otherwise.

        """
        return _libsbml.XMLToken_hasNamespaceURI(self, uri)


    def hasNamespacePrefix(self, prefix):
        """
        hasNamespacePrefix(XMLToken self, string prefix) -> bool


        Returns 'True' if this token has an XML namespace with a given prefix.

        Parameter 'prefix' is a string, the prefix for the XML namespace.

        Returns 'True' if an XML Namespace with the given URI is contained in
        the XMLNamespaces of this XMLToken, 'False' otherwise.

        """
        return _libsbml.XMLToken_hasNamespacePrefix(self, prefix)


    def hasNamespaceNS(self, uri, prefix):
        """
        hasNamespaceNS(XMLToken self, string uri, string prefix) -> bool


        Returns 'True' if this token has an XML namespace with a given prefix
        and URI combination.

        Parameter 'uri' is a string, the URI for the namespace. Parameter
        'prefix' is a string, the prefix for the namespace.

        Returns 'True' if an XML namespace with the given URI/prefix pair is
        contained in the XMLNamespaces object of this XMLToken object, 'False'
        otherwise.

        """
        return _libsbml.XMLToken_hasNamespaceNS(self, uri, prefix)


    def setTriple(self, triple):
        """
        setTriple(XMLToken self, XMLTriple triple) -> int


        Sets the name, namespace prefix and namespace URI of this token.

        This operation only makes sense for XML start elements.  This method
        will return LIBSBML_INVALID_XML_OPERATION if this XMLToken object is
        not an XML start element.

        Parameter 'triple' is the new XMLTriple to use for this XMLToken
        object.  If this XMLToken already had an XMLTriple object stored
        within it, that object will be replaced.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_XML_OPERATION

        * LIBSBML_INVALID_OBJECT

        """
        return _libsbml.XMLToken_setTriple(self, triple)


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


        Returns the (unqualified) name of token.

        Returns the (unqualified) name of token.

        """
        return _libsbml.XMLToken_getName(self)


    def getPrefix(self):
        """
        getPrefix(XMLToken self) -> string


        Returns the XML namespace prefix of token.

        Returns the XML namespace prefix of token.

        Note: If no XML namespace prefix has been assigned to this token, this
        method will return an empty string.

        """
        return _libsbml.XMLToken_getPrefix(self)


    def getURI(self):
        """
        getURI(XMLToken self) -> string


        Returns the XML namespace URI of token.

        Returns the XML namespace URI of token.

        """
        return _libsbml.XMLToken_getURI(self)


    def getCharacters(self):
        """
        getCharacters(XMLToken self) -> string


        Returns the character text of token.

        Returns the characters of this XML token.  If this token is not a text
        token (i.e., it's an XML element and not character content), then this
        will return an empty string.

        See also isText(), isElement().

        """
        return _libsbml.XMLToken_getCharacters(self)


    def setCharacters(self, chars):
        """
        setCharacters(XMLToken self, string chars) -> int


        Sets the characters for this XMLToken

        This method only makes sense for XMLToken objects that contains text.
        If this method is called on a token that represents an XML start or
        end tag, it will return the code LIBSBML_OPERATION_FAILED.

        Parameter 'chars' is string, characters to append to the text of this
        token.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also isText(), isElement().

        """
        return _libsbml.XMLToken_setCharacters(self, chars)


    def append(self, chars):
        """
        append(XMLToken self, string chars) -> int


        Appends characters to the text content of token.

        This method only makes sense for XMLToken objects that contains text.
        If this method is called on a token that represents an XML start or
        end tag, it will return the code LIBSBML_OPERATION_FAILED.

        Parameter 'chars' is string, characters to append to the text of this
        token.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also isText(), isElement().

        """
        return _libsbml.XMLToken_append(self, chars)


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


        Returns the column number at which this token occurs in the input.

        Returns the column at which this XMLToken occurred.

        """
        return _libsbml.XMLToken_getColumn(self)


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


        Returns the line number at which this token occurs in the input.

        Returns the line at which this XMLToken occurred.

        """
        return _libsbml.XMLToken_getLine(self)


    def isElement(self):
        """
        isElement(XMLToken self) -> bool


        Returns 'True' if this token represents an XML element.

        This generic predicate returns 'True' if the element is either a start
        or end tag, and 'False' if it's a text object.  The related methods
        XMLToken:isStart(), XMLToken.isEnd() and XMLToken.isText() are more
        specific predicates.

        Returns 'True' if this XMLToken object represents an XML element,
        'False' otherwise.

        See also isStart(), isEnd(), isText().

        """
        return _libsbml.XMLToken_isElement(self)


    def isEnd(self):
        """
        isEnd(XMLToken self) -> bool


        Returns 'True' if this token represents an XML end element.

        Returns 'True' if this XMLToken object represents an XML end element,
        'False' otherwise.

        See also isStart(), isElement(), isText().

        """
        return _libsbml.XMLToken_isEnd(self)


    def isEndFor(self, element):
        """
        isEndFor(XMLToken self, XMLToken element) -> bool


        Returns 'True' if this token represents an XML end element for a
        particular start element.

        Parameter 'element' is XMLToken, the element with which the current
        object should be compared to determined whether the current object is
        a start element for the given one.

        Returns 'True' if this XMLToken object represents an XML end tag for
        the start tag given by 'element', 'False' otherwise.

        See also isElement(), isStart(), isEnd(), isText().

        """
        return _libsbml.XMLToken_isEndFor(self, element)


    def isEOF(self):
        """
        isEOF(XMLToken self) -> bool


        Returns 'True' if this token is an end of file marker.

        Returns 'True' if this XMLToken object represents the end of the
        input, 'False' otherwise.

        See also setEOF().

        """
        return _libsbml.XMLToken_isEOF(self)


    def isStart(self):
        """
        isStart(XMLToken self) -> bool


        Returns 'True' if this token represents an XML start element.

        Returns 'True' if this XMLToken is an XML start element, 'False'
        otherwise.

        See also isElement(), isEnd(), isText().

        """
        return _libsbml.XMLToken_isStart(self)


    def isText(self):
        """
        isText(XMLToken self) -> bool


        Returns 'True' if this token represents an XML text element.

        Returns 'True' if this XMLToken is an XML text element, 'False'
        otherwise.

        See also isElement(), isStart(), isEnd().

        """
        return _libsbml.XMLToken_isText(self)


    def setEnd(self):
        """
        setEnd(XMLToken self) -> int


        Declares that this token represents an XML element end tag.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also isStart(), isEnd().

        """
        return _libsbml.XMLToken_setEnd(self)


    def setEOF(self):
        """
        setEOF(XMLToken self) -> int


        Declares that this token is an end-of-file/input marker.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also isEOF().

        """
        return _libsbml.XMLToken_setEOF(self)


    def unsetEnd(self):
        """
        unsetEnd(XMLToken self) -> int


        Declares that this token no longer represents an XML start/end
        element.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.XMLToken_unsetEnd(self)


    def toString(self):
        """
        toString(XMLToken self) -> string


        Prints a string representation of the underlying token stream.

        This method is intended for debugging purposes.

        Returns a text string representing this XMLToken object.

        """
        return _libsbml.XMLToken_toString(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

XMLToken_swigregister = _libsbml.XMLToken_swigregister
XMLToken_swigregister(XMLToken)

class XMLNode(XMLToken):
    """

    A node in libSBML's XML document tree.

    LibSBML implements an XML abstraction layer.  This layer presents a
    uniform XML interface to calling programs regardless of which
    underlying XML parser libSBML has actually been configured to use.
    The basic data object in the XML abstraction is a node, represented by
    XMLNode.

    An XMLNode can contain any number of children.  Each child is another
    XMLNode, thereby forming a tree.  The methods XMLNode.getNumChildren()
    and XMLNode.getChild() can be used to access the tree structure
    starting from a given node.

    Each XMLNode is subclassed from XMLToken, and thus has the same
    methods available as XMLToken.  These methods include
    XMLToken.getNamespaces(), XMLToken.getPrefix(), XMLToken.getName(),
    XMLToken.getURI(), and XMLToken.getAttributes().

    Conversion between an XML string and an XMLNode
    ======================================================================

    LibSBML provides the following utility functions for converting an XML
    string (e.g., <annotation>...</annotation>) to/from an XMLNode object.

    * XMLNode.toXMLString() returns a string representation of the
    XMLNode object.

    * XMLNode.convertXMLNodeToString() (static function) returns a
    string representation of the given XMLNode object.

    * XMLNode.convertStringToXMLNode() (static function) returns an
    XMLNode object converted from the given XML string.

    The returned XMLNode object by XMLNode.convertStringToXMLNode() is a
    dummy root (container) XMLNode if the given XML string has two or more
    top-level elements (e.g., "<p>...<p>..."). In the dummy root node,
    each top-level element in the given XML string is contained as a child
    XMLNode. XMLToken.isEOF() can be used to identify if the returned
    XMLNode object is a dummy node or not.  Here is an example:

      xn = XMLNode.convertStringToXMLNode('<p></p>')
      if xn == None:
        # Do something to handle exceptional situation.

      elif xn.isEOF():
        # Node is a dummy node.

      else:
        # None is not a dummy node.

    """

    __swig_setmethods__ = {}
    for _s in [XMLToken]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, XMLNode, name, value)
    __swig_getmethods__ = {}
    for _s in [XMLToken]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, XMLNode, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_XMLNode
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(XMLNode self) -> XMLNode
        __init__(XMLNode self, XMLToken token) -> XMLNode
        __init__(XMLNode self, XMLTriple triple, XMLAttributes attributes, XMLNamespaces namespaces, unsigned int const line=0, unsigned int const column=0) -> XMLNode
        __init__(XMLNode self, XMLTriple triple, XMLAttributes attributes, XMLNamespaces namespaces, unsigned int const line=0) -> XMLNode
        __init__(XMLNode self, XMLTriple triple, XMLAttributes attributes, XMLNamespaces namespaces) -> XMLNode
        __init__(XMLNode self, XMLTriple triple, XMLAttributes attributes, unsigned int const line=0, unsigned int const column=0) -> XMLNode
        __init__(XMLNode self, XMLTriple triple, XMLAttributes attributes, unsigned int const line=0) -> XMLNode
        __init__(XMLNode self, XMLTriple triple, XMLAttributes attributes) -> XMLNode
        __init__(XMLNode self, XMLTriple triple, unsigned int const line=0, unsigned int const column=0) -> XMLNode
        __init__(XMLNode self, XMLTriple triple, unsigned int const line=0) -> XMLNode
        __init__(XMLNode self, XMLTriple triple) -> XMLNode
        __init__(XMLNode self, string chars, unsigned int const line=0, unsigned int const column=0) -> XMLNode
        __init__(XMLNode self, string chars, unsigned int const line=0) -> XMLNode
        __init__(XMLNode self, string chars) -> XMLNode
        __init__(XMLNode self, XMLInputStream stream) -> XMLNode
        __init__(XMLNode self, XMLNode orig) -> XMLNode


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            XMLNode(XMLToken token)

        Creates a new XMLNode by copying an XMLToken object.

        Parameter 'token' is XMLToken to be copied to XMLNode.

        ______________________________________________________________________
        Method variant with the following signature:

            XMLNode(  XMLTriple     triple , XMLAttributes attributes ,
        XMLNamespaces namespaces ,  long   line   = 0 ,  long   column = 0 )

        Creates a new start element XMLNode with the given set of attributes
        and namespace declarations.

        Parameter 'triple' is XMLTriple. Parameter 'attributes' is
        XMLAttributes, the attributes to set. Parameter 'namespaces' is
        XMLNamespaces, the namespaces to set. Parameter 'line' is a long
        integer, the line number (default = 0). Parameter 'column' is a long
        integer, the column number (default = 0).

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            XMLNode(XMLNode orig)

        Copy constructor; creates a copy of this XMLNode.

        Parameter 'orig' is the XMLNode instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            XMLNode()

        Creates a new empty XMLNode with no children.

        ______________________________________________________________________
        Method variant with the following signature:

            XMLNode(  XMLTriple      triple , XMLAttributes  attributes ,
        long    line   = 0 ,  long    column = 0 )

        Creates a start element XMLNode with the given set of attributes.

        Parameter 'triple' is XMLTriple. Parameter 'attributes' is
        XMLAttributes, the attributes to set. Parameter 'line' is a long
        integer, the line number (default = 0). Parameter 'column' is a long
        integer, the column number (default = 0).

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            XMLNode(  XMLTriple    triple ,  long  line   = 0 ,  long
        column = 0 )

        Creates an end element XMLNode.

        Parameter 'triple' is XMLTriple. Parameter 'line' is a long integer,
        the line number (default = 0). Parameter 'column' is a long integer,
        the column number (default = 0).

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            XMLNode(  string  chars ,  long  line   = 0 ,  long  column =
        0 )

        Creates a text XMLNode.

        Parameter 'chars' is a string, the text to be added to the XMLToken.
        Parameter 'line' is a long integer, the line number (default = 0).
        Parameter 'column' is a long integer, the column number (default = 0).

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        this = _libsbml.new_XMLNode(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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


        Creates and returns a deep copy of this XMLNode object.

        Returns the (deep) copy of this XMLNode object.

        """
        return _libsbml.XMLNode_clone(self)


    def addChild(self, node):
        """
        addChild(XMLNode self, XMLNode node) -> int


        Adds a copy of 'node' as a child of this XMLNode.

        The given 'node' is added at the end of the list of children.

        Parameter 'node' is the XMLNode to be added as child.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_XML_OPERATION

        Note: The given node is added at the end of the children list.

        """
        return _libsbml.XMLNode_addChild(self, node)


    def insertChild(self, n, node):
        """
        insertChild(XMLNode self, unsigned int n, XMLNode node) -> XMLNode


        Inserts a copy of the given node as the nth child of this XMLNode.

        If the given index 'n' is out of range for this XMLNode instance, the
        'node' is added at the end of the list of children.  Even in that
        situation, this method does not throw an error.

        Parameter 'n' is an integer, the index at which the given node is
        inserted. Parameter 'node' is an XMLNode to be inserted as nth child.

        Returns a reference to the newly-inserted child 'node'.

        """
        return _libsbml.XMLNode_insertChild(self, n, node)


    def removeChild(self, n):
        """
        removeChild(XMLNode self, unsigned int n) -> XMLNode


        Removes the nth child of this XMLNode and returns the removed node.

        It is important to keep in mind that a given XMLNode may have more
        than one child.  Calling this method erases all existing references to
        child nodes after the given position 'n'.  If the index 'n' is greater
        than the number of child nodes in this XMLNode, this method takes no
        action (and returns 'None).'

        Parameter 'n' is an integer, the index of the node to be removed.

        Returns the removed child, or 'None' if 'n' is greater than the number
        of children in this node.

        Note: The caller owns the returned node and is responsible for
        deleting it.

        """
        return _libsbml.XMLNode_removeChild(self, n)


    def removeChildren(self):
        """
        removeChildren(XMLNode self) -> int


        Removes all children from this node. Returns integer value indicating
        success/failure of the function.   The possible values returned by
        this function are:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.XMLNode_removeChildren(self)


    def getChild(self, *args):
        """
        getChild(XMLNode self, unsigned int n) -> XMLNode
        getChild(XMLNode self, unsigned int n) -> XMLNode
        getChild(XMLNode self, string name) -> XMLNode
        getChild(XMLNode self, string name) -> XMLNode


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getChild(long n)

        Returns the  nth child of this XMLNode.

        If the index 'n' is greater than the number of child nodes, this
        method returns an empty node.

        Parameter 'n' is a long integereger, the index of the node to return.

        Returns the nth child of this XMLNode.

        ______________________________________________________________________
        Method variant with the following signature:

            getChild(string  name)

        Returns the first child of this XMLNode with the corresponding name.

        If no child with corrsponding name can be found, this method returns
        an empty node.

        Parameter 'name' is the name of the node to return.

        Returns the first child of this XMLNode with given name.

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


    def getIndex(self, name):
        """
        getIndex(XMLNode self, string name) -> int


        Return the index of the first child of this XMLNode with the given
        name.

        Parameter 'name' is a string, the name of the child for which the
        index is required.

        Returns the index of the first child of this XMLNode with the given
        name, or '-1' if not present.

        """
        return _libsbml.XMLNode_getIndex(self, name)


    def hasChild(self, name):
        """
        hasChild(XMLNode self, string name) -> bool


        Return a boolean indicating whether this XMLNode has a child with the
        given name.

        Parameter 'name' is a string, the name of the child to be checked.

        Returns boolean indicating whether this XMLNode has a child with the
        given name.

        """
        return _libsbml.XMLNode_hasChild(self, name)


    def equals(self, other, ignoreURI=False, ignoreAttributeValues=False):
        """
        equals(XMLNode self, XMLNode other, bool ignoreURI=False, bool ignoreAttributeValues=False) -> bool
        equals(XMLNode self, XMLNode other, bool ignoreURI=False) -> bool
        equals(XMLNode self, XMLNode other) -> bool


        Compare this XMLNode against another XMLNode returning true if both
        nodes represent the same XML tree, or false otherwise.

        Parameter 'other' is another XMLNode to compare against.

        Parameter 'ignoreURI' is whether to ignore the namespace URI when
        doing the comparison.

        Parameter 'ignoreAttributeValues' is whetehr to ignore attribute
        values when  doing the comparison.

        Returns boolean indicating whether this XMLNode represents the same
        XML tree as another.

        """
        return _libsbml.XMLNode_equals(self, other, ignoreURI, ignoreAttributeValues)


    def getNumChildren(self):
        """
        getNumChildren(XMLNode self) -> unsigned int


        Returns the number of children for this XMLNode.

        Returns the number of children for this XMLNode.

        """
        return _libsbml.XMLNode_getNumChildren(self)


    def writeToStream(self, stream):
        """
        writeToStream(XMLNode self, XMLOutputStream stream)


        Internal implementation method.

        """
        return _libsbml.XMLNode_writeToStream(self, stream)


    def toXMLString(self):
        """
        toXMLString(XMLNode self) -> string


        Returns a string representation of this XMLNode.

        Returns a string derived from this XMLNode.

        """
        return _libsbml.XMLNode_toXMLString(self)


    def convertXMLNodeToString(node):
        """
        convertXMLNodeToString(XMLNode node) -> string


        Returns a string representation of a given XMLNode.

        Parameter 'node' is the XMLNode to be represented as a string.

        Returns a string-form representation of 'node'.

        """
        return _libsbml.XMLNode_convertXMLNodeToString(node)

    convertXMLNodeToString = staticmethod(convertXMLNodeToString)

    def convertStringToXMLNode(xmlstr, xmlns=None):
        """
        convertStringToXMLNode(string xmlstr, XMLNamespaces xmlns=None) -> XMLNode
        convertStringToXMLNode(string xmlstr) -> XMLNode


        Returns an XMLNode which is derived from a string containing XML
        content.

        The XML namespace must be defined using argument 'xmlns' if the
        corresponding XML namespace attribute is not part of the string of the
        first argument.

        Parameter 'xmlstr' is string to be converted to a XML node. Parameter
        'xmlns' is XMLNamespaces the namespaces to set (default value is
        'None).'

        Note: The caller owns the returned XMLNode and is reponsible for
        deleting it.  The returned XMLNode object is a dummy root (container)
        XMLNode if the top-level element in the given XML string is NOT
        <html>, <body>, <annotation>, or <notes>.  In the dummy root node,
        each top-level element in the given XML string is contained as a child
        XMLNode. XMLToken.isEOF() can be used to identify if the returned
        XMLNode object is a dummy node.

        Returns a XMLNode which is converted from string 'xmlstr'.  If the
        conversion failed, this method returns 'None.'

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        return _libsbml.XMLNode_convertStringToXMLNode(xmlstr, xmlns)

    convertStringToXMLNode = staticmethod(convertStringToXMLNode)
XMLNode_swigregister = _libsbml.XMLNode_swigregister
XMLNode_swigregister(XMLNode)

def XMLNode_convertXMLNodeToString(node):
    """
    XMLNode_convertXMLNodeToString(XMLNode node) -> string


    Returns a string representation of a given XMLNode.

    Parameter 'node' is the XMLNode to be represented as a string.

    Returns a string-form representation of 'node'.

    """
    return _libsbml.XMLNode_convertXMLNodeToString(node)

def XMLNode_convertStringToXMLNode(xmlstr, xmlns=None):
    """
    convertStringToXMLNode(string xmlstr, XMLNamespaces xmlns=None) -> XMLNode
    XMLNode_convertStringToXMLNode(string xmlstr) -> XMLNode


    Returns an XMLNode which is derived from a string containing XML
    content.

    The XML namespace must be defined using argument 'xmlns' if the
    corresponding XML namespace attribute is not part of the string of the
    first argument.

    Parameter 'xmlstr' is string to be converted to a XML node. Parameter
    'xmlns' is XMLNamespaces the namespaces to set (default value is
    'None).'

    Note: The caller owns the returned XMLNode and is reponsible for
    deleting it.  The returned XMLNode object is a dummy root (container)
    XMLNode if the top-level element in the given XML string is NOT
    <html>, <body>, <annotation>, or <notes>.  In the dummy root node,
    each top-level element in the given XML string is contained as a child
    XMLNode. XMLToken.isEOF() can be used to identify if the returned
    XMLNode object is a dummy node.

    Returns a XMLNode which is converted from string 'xmlstr'.  If the
    conversion failed, this method returns 'None.'

    </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

    Note: Owing to the way that language interfaces are created in
    libSBML, this documentation may show methods that define default
    values for parameters with text that has the form parameter = value.
    This is not to be intepreted as a Python keyword argument; the use of
    a parameter name followed by an equals sign followed by a value is
    only meant to indicate a default value if the argument is not provided
    at all.  It is not a keyword in the Python sense.

    """
    return _libsbml.XMLNode_convertStringToXMLNode(xmlstr, xmlns)

class XMLTriple(_object):
    """

    A qualified XML name.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    A 'triple' in the libSBML XML layer encapsulates the notion of
    qualified name, meaning an element name or an attribute name with an
    optional namespace qualifier.  Triples by themselves are not entities
    in an XML stream -- they are not, for example, elements or attributes;
    rather, XMLTriple is used in libSBML to construct these other kinds of
    objects.

    An XMLTriple instance carries up to three data items: <ol>

    * The name of the attribute or element; that is, the attribute name
    as it appears in an XML document or data stream;

    * The XML namespace prefix (if any) of the attribute.  For example,
    in the following fragment of XML, the namespace prefix is the string
    mysim and it appears on both the element someelement and the attribute
    attribA.  When both the element and the attribute are stored as
    XMLTriple objects, their prefix is mysim.

      <mysim:someelement mysim:attribA='value' />

    * The XML namespace URI with which the prefix is associated.  In XML,
    every namespace used must be declared and mapped to a URI. </ol>

    XMLTriple objects are the lowest-level data item in the XML layer of
    libSBML.  Other objects such as XMLToken make use of XMLTriple
    objects.

    See also XMLToken, XMLNode, XMLAttributes, XMLNamespaces.

    """

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, XMLTriple, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, XMLTriple, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(XMLTriple self) -> XMLTriple
        __init__(XMLTriple self, string name, string uri, string prefix) -> XMLTriple
        __init__(XMLTriple self, string triplet, char const sepchar) -> XMLTriple
        __init__(XMLTriple self, string triplet) -> XMLTriple
        __init__(XMLTriple self, XMLTriple orig) -> XMLTriple


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            XMLTriple(  string  name , string  uri , string  prefix )

        Creates a new XMLTriple object with a given 'name', 'uri' and and
        'prefix'.

        Parameter 'name' is a string, the name for the entity represented by
        this object. Parameter 'uri' is a string, the XML namespace URI
        associated with the prefix. Parameter 'prefix' is a string, the XML
        namespace prefix for this triple.

        ______________________________________________________________________
        Method variant with the following signature:

            XMLTriple(string triplet,  char sepchar = ' ')

        Creates an XMLTriple object by splitting a given string at a given
        separator character.

        The 'triplet' in this case is a string that may be in one of the
        following three possible formats: <ol>

        * name * URIxname* URIxnamexprefix</ol>

        where x represents the separator character, 'sepchar'.

        Parameter 'triplet' is a string representing the triplet as shown
        above. Parameter 'sepchar' is a character, the sepchar used in the
        triplet.

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            XMLTriple()

        Creates a new, empty XMLTriple object.

        ______________________________________________________________________
        Method variant with the following signature:

            XMLTriple(XMLTriple orig)

        Copy constructor; creates a copy of this XMLTriple object.

        Parameter 'orig' is the XMLTriple object to copy.

        """
        this = _libsbml.new_XMLTriple(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(XMLTriple self) -> XMLTriple


        Creates and returns a deep copy of this XMLTriple object.

        Returns the (deep) copy of this XMLTriple object.

        """
        return _libsbml.XMLTriple_clone(self)


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


        Returns the name portion of this XMLTriple object.

        Returns a string, the name portion of this XMLTriple object.

        """
        return _libsbml.XMLTriple_getName(self)


    def getPrefix(self):
        """
        getPrefix(XMLTriple self) -> string


        Returns the prefix portion of this XMLTriple object.

        Returns a string, the prefix portion of this XMLTriple object.

        """
        return _libsbml.XMLTriple_getPrefix(self)


    def getURI(self):
        """
        getURI(XMLTriple self) -> string


        Returns the URI portion of this XMLTriple object.

        Returns URI a string, the URI portion of this XMLTriple object.

        """
        return _libsbml.XMLTriple_getURI(self)


    def getPrefixedName(self):
        """
        getPrefixedName(XMLTriple self) -> string


        Returns the prefixed name from this XMLTriple.

        Returns a string, the prefixed name from this XMLTriple.  This is
        constructed by concatenating the prefix stored in this XMLTriple
        object, followed by a colon character ':', followed by the name stored
        in this XMLTriple object.

        """
        return _libsbml.XMLTriple_getPrefixedName(self)


    def isEmpty(self):
        """
        isEmpty(XMLTriple self) -> bool


        Returns 'True' if this XMLTriple object is empty.

        Returns 'True' if this XMLTriple is empty, 'False' otherwise.

        """
        return _libsbml.XMLTriple_isEmpty(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

    __swig_destroy__ = _libsbml.delete_XMLTriple
    __del__ = lambda self: None
XMLTriple_swigregister = _libsbml.XMLTriple_swigregister
XMLTriple_swigregister(XMLTriple)

class XMLOutputStream(_object):
    """

    Interface to an XML output stream.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    SBML content is serialized using XML; the resulting data can be
    stored and read to/from a file or data stream.  Low-level XML parsers
    such as Xerces provide facilities to read XML data.  To permit the use
    of different XML parsers (Xerces, Expat or libxml2), libSBML
    implements an abstraction layer.  XMLInputStream and XMLOutputStream
    are two parts of that abstraction layer.

    XMLOutputStream provides a wrapper above output streams to facilitate
    writing XML.  XMLOutputStream keeps track of start and end elements,
    indentation, XML namespace prefixes, and more.  The interface provides
    features for converting non-text data types into appropriate textual
    form; this takes the form of overloaded writeAttribute(...) methods
    that allow users to simply use the same method with any data type.
    For example, suppose an element 'testElement' has two attributes,
    'size' and 'id,' and the attributes are variables in your code as
    follows:

      size = 3.2;
      id = 'id';

    Then, the element and the attributes can be written to the standard
    output stream (provided as 'cout' in the libSBML language bindings) as
    follows:

      from libsbml import *

      size = 3.2;
      id = 'id';

      # Create an XMLOutputStream object that will write to the standard
      # output stream, which is provide in libSBML's Python language
      # interface as the object 'libsbml.cout'.  Since we imported * from
      # the libsbml module, we can simply refer to it as 'cout' here:

      output_stream = XMLOutputStream(cout)

      # Create the start element, write the attributes, and close the
      # element.  The output is written immediately by each method.

      output_stream.startElement('testElement')
      output_stream.writeAttribute('size', size)
      output_stream.writeAttribute('id', id)
      output_stream.endElement('testElement')

    Other classes in SBML take XMLOutputStream objects as arguments, and
    use that to write elements and attributes seamlessly to the XML output
    stream.

    It is also worth noting that unlike XMLInputStream, XMLOutputStream is
    actually independent of the underlying XML parsers.  It does not use
    the XML parser libraries at all.

    Note: The convenience of the XMLInputStream and XMLOutputStream
    abstraction may be useful for developers interested in creating
    parsers for other XML formats besides SBML.  It can provide developers
    with a layer above more basic XML parsers, as well as some useful
    programmatic elements such as XMLToken, XMLError, etc.

    See also XMLInputStream.

    """

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, XMLOutputStream, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, XMLOutputStream, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(XMLOutputStream self, ostream stream, string encoding, bool writeXMLDecl=True, string programName, string programVersion) -> XMLOutputStream
        __init__(XMLOutputStream self, ostream stream, string encoding, bool writeXMLDecl=True, string programName) -> XMLOutputStream
        __init__(XMLOutputStream self, ostream stream, string encoding, bool writeXMLDecl=True) -> XMLOutputStream
        __init__(XMLOutputStream self, ostream stream, string encoding) -> XMLOutputStream
        __init__(XMLOutputStream self, ostream stream) -> XMLOutputStream


        Creates a new XMLOutputStream that wraps the given @p stream.

        The functionality associated with the @p programName and @p
        programVersion arguments concerns an optional comment that libSBML can
        write at the beginning of the output stream.  The comment is intended
        for human readers of the XML file, and has the following form:
        @verbatim
        <!-- Created by <program name> version <program version>
        on yyyy-MM-dd HH:mm with libSBML version <libsbml version>. -->
        @endverbatim

        This program information comment is a separate item from the XML
        declaration that this method can also write to this output stream.  The
        comment is also not mandated by any SBML specification.  This libSBML
        functionality is provided for the convenience of calling programs, and to
        help humans trace the origin of SBML files.

        LibSBML tries to produce human-readable XML output by automatically
        indenting the bodies of elements.  Callers can manually control
        indentation further by using the XMLOutputStream::upIndent()
        and XMLOutputStream::downIndent() methods to increase and
        decrease, respectively, the current level of indentation in the
        XML output.

        @param stream the input stream to wrap.

        @param encoding the XML encoding to declare in the output. This value should
        be <code>&quot;UTF-8&quot;</code> for SBML documents.  The default value is
        <code>&quot;UTF-8&quot;</code> if no value is supplied for this parameter.

        @param writeXMLDecl whether to write a standard XML declaration at
        the beginning of the content written on @p stream.  The default is
        @c true.

        @param programName an optional program name to write as a comment
        in the output stream.

        @param programVersion an optional version identification string to write
        as a comment in the output stream.

        @htmlinclude warn-default-args-in-docs.html

        """
        this = _libsbml.new_XMLOutputStream(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_XMLOutputStream
    __del__ = lambda self: None

    def endElement(self, *args):
        """
        endElement(XMLOutputStream self, string name, string prefix)
        endElement(XMLOutputStream self, string name)
        endElement(XMLOutputStream self, XMLTriple triple, bool text=False)
        endElement(XMLOutputStream self, XMLTriple triple)


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            endElement(string name, string prefix = '')

        Writes the given XML end element name to this XMLOutputStream.

        Parameter 'name' is the name of the element.

        Parameter 'prefix' is an optional XML namespace prefix to write in
        front of the 'element' name.  (The result has the form prefix:name.)

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            endElement(XMLTriple triple, bool text = false)

        Writes the given element to the stream.

        Parameter 'triple' is the XML element to write. Parameter 'text' is
        the text to put

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

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


    def setAutoIndent(self, indent):
        """
        setAutoIndent(XMLOutputStream self, bool indent)


        Turns automatic indentation on or off for this XMLOutputStream.

        Parameter 'indent' is if 'True,' automatic indentation is turned on.

        """
        return _libsbml.XMLOutputStream_setAutoIndent(self, indent)


    def startElement(self, *args):
        """
        startElement(XMLOutputStream self, string name, string prefix)
        startElement(XMLOutputStream self, string name)
        startElement(XMLOutputStream self, XMLTriple triple)


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            startElement(XMLTriple triple)

        Writes the given XML start element prefix:name on this output stream.

        Parameter 'triple' is the start element to write.

        ______________________________________________________________________
        Method variant with the following signature:

            startElement(string name, string prefix = '')

        Writes the given XML start element name to this XMLOutputStream.

        Parameter 'name' is the name of the element.

        Parameter 'prefix' is an optional XML namespace prefix to write in
        front of the 'element' name.  (The result has the form prefix:name.)

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

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


    def startEndElement(self, *args):
        """
        startEndElement(XMLOutputStream self, string name, string prefix)
        startEndElement(XMLOutputStream self, string name)
        startEndElement(XMLOutputStream self, XMLTriple triple)


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            startEndElement(XMLTriple triple)

        Writes the given start element to this output stream.

        Parameter 'triple' is the XML element to write.

        ______________________________________________________________________
        Method variant with the following signature:

            startEndElement(string name, string prefix = '')

        Writes the given XML start and end element name to this
        XMLOutputStream.

        Parameter 'name' is the name of the element.

        Parameter 'prefix' is an optional XML namespace prefix to write in
        front of the 'element' name.  (The result has the form prefix:name.)

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

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


    def writeAttribute(self, *args):
        """
        writeAttribute(XMLOutputStream self, string name, string value)
        writeAttribute(XMLOutputStream self, string name, string prefix, string value)
        writeAttribute(XMLOutputStream self, XMLTriple triple, string value)
        writeAttribute(XMLOutputStream self, string name, char const * value)
        writeAttribute(XMLOutputStream self, string name, string prefix, char const * value)
        writeAttribute(XMLOutputStream self, XMLTriple triple, char const * value)
        writeAttribute(XMLOutputStream self, string name, bool const & value)
        writeAttribute(XMLOutputStream self, string name, string prefix, bool const & value)
        writeAttribute(XMLOutputStream self, XMLTriple triple, bool const & value)
        writeAttribute(XMLOutputStream self, string name, double const & value)
        writeAttribute(XMLOutputStream self, string name, string prefix, double const & value)
        writeAttribute(XMLOutputStream self, XMLTriple triple, double const & value)
        writeAttribute(XMLOutputStream self, string name, long const & value)
        writeAttribute(XMLOutputStream self, string name, string prefix, long const & value)
        writeAttribute(XMLOutputStream self, XMLTriple triple, long const & value)
        writeAttribute(XMLOutputStream self, string name, int const & value)
        writeAttribute(XMLOutputStream self, string name, string prefix, int const & value)
        writeAttribute(XMLOutputStream self, XMLTriple triple, int const & value)
        writeAttribute(XMLOutputStream self, string name, string prefix, unsigned int const & value)


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            writeAttribute(XMLTriple triple, string value)

        Writes the given attribute and value to this output stream.

        Parameter 'triple' is the attribute, in the form of an XMLTriple.

        Parameter 'value' is the value of the attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            writeAttribute(string name, string prefix, long value)

        Writes the given namespace-prefixed attribute value to this output
        stream.

        Parameter 'name' is the name of the attribute.

        Parameter 'prefix' is an XML namespace prefix to write in front of the
        'element' name.  (The result has the form prefix:name.)  See other
        versions of this method for a variant that does not require a prefix.

        Parameter 'value' is the value of the attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            writeAttribute(string name, string prefix, string value)

        Writes the given namespace-prefixed attribute value to this output
        stream.

        Parameter 'name' is the name of the attribute.

        Parameter 'prefix' is an XML namespace prefix to write in front of the
        'element' name.  (The result has the form prefix:name.)  See other
        versions of this method for a variant that does not require a prefix.

        Parameter 'value' is the value of the attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            writeAttribute(XMLTriple triple,  bool value)

        Writes the given attribute and value to this output stream.

        Parameter 'triple' is the attribute, in the form of an XMLTriple.

        Parameter 'value' is the value of the attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            writeAttribute(string name, long value)

        Writes the given attribute and value to this output stream.

        Parameter 'name' is the name of the attribute.

        Parameter 'value' is the value of the attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            writeAttribute(XMLTriple triple, long value)

        Writes the given attribute and value to this output stream.

        Parameter 'triple' is the attribute, in the form of an XMLTriple.

        Parameter 'value' is the value of the attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            writeAttribute(XMLTriple triple, long value)

        Writes the given attribute and value to this output stream.

        Parameter 'triple' is the attribute, in the form of an XMLTriple.

        Parameter 'value' is the value of the attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            writeAttribute(string name,  long value)

        Writes the given attribute and value to this output stream.

        Parameter 'name' is the name of the attribute.

        Parameter 'value' is the value of the attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            writeAttribute(string name, string value)

        Writes the given attribute and value to this output stream.

        Parameter 'name' is the name of the attribute.

        Parameter 'value' is the value of the attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            writeAttribute(string name, string value)

        Writes the given attribute and value to this output stream.

        Parameter 'name' is the name of the attribute.

        Parameter 'value' is the value of the attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            writeAttribute(string name, string prefix,  long value)

        Writes the given namespace-prefixed attribute value to this output
        stream.

        Parameter 'name' is the name of the attribute.

        Parameter 'prefix' is an XML namespace prefix to write in front of the
        'element' name.  (The result has the form prefix:name.)  See other
        versions of this method for a variant that does not require a prefix.

        Parameter 'value' is the value of the attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            writeAttribute(string name, string prefix, long value)

        Writes the given namespace-prefixed attribute value to this output
        stream.

        Parameter 'name' is the name of the attribute.

        Parameter 'prefix' is an XML namespace prefix to write in front of the
        'element' name.  (The result has the form prefix:name.)  See other
        versions of this method for a variant that does not require a prefix.

        Parameter 'value' is the value of the attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            writeAttribute(string name, string prefix,  int value)

        Writes the given namespace-prefixed attribute value to this output
        stream.

        Parameter 'name' is the name of the attribute.

        Parameter 'prefix' is an XML namespace prefix to write in front of the
        'element' name.  (The result has the form prefix:name.)  See other
        versions of this method for a variant that does not require a prefix.

        Parameter 'value' is the value of the attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            writeAttribute(XMLTriple triple,  long value)

        Writes the given attribute and value to this output stream.

        Parameter 'triple' is the attribute, in the form of an XMLTriple.

        Parameter 'value' is the value of the attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            writeAttribute(string name,  int value)

        Writes the given attribute and value to this output stream.

        Parameter 'name' is the name of the attribute.

        Parameter 'value' is the value of the attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            writeAttribute(XMLTriple triple,  int value)

        Writes the given attribute and value to this output stream.

        Parameter 'triple' is the attribute, in the form of an XMLTriple.

        Parameter 'value' is the value of the attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            writeAttribute(string name,  bool value)

        Writes the given attribute and value to this output stream.

        Parameter 'name' is the name of the attribute.

        Parameter 'value' is the value of the attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            writeAttribute(XMLTriple triple, string value)

        Writes the given attribute and value to this output stream.

        Parameter 'triple' is the attribute, in the form of an XMLTriple.

        Parameter 'value' is the value of the attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            writeAttribute(string name, long value)

        Writes the given attribute and value to this output stream.

        Parameter 'name' is the name of the attribute.

        Parameter 'value' is the value of the attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            writeAttribute(string name, string prefix, string value)

        Writes the given namespace-prefixed attribute value to this output
        stream.

        Parameter 'name' is the name of the attribute.

        Parameter 'prefix' is an XML namespace prefix to write in front of the
        'element' name.  (The result has the form prefix:name.)  See other
        versions of this method for a variant that does not require a prefix.

        Parameter 'value' is the value of the attribute.

        ______________________________________________________________________
        Method variant with the following signature:

            writeAttribute(string name, string &prefix,  bool value)

        Writes the given namespace-prefixed attribute value to this output
        stream.

        Parameter 'name' is the name of the attribute.

        Parameter 'prefix' is an XML namespace prefix to write in front of the
        'element' name.  (The result has the form prefix:name.)  See other
        versions of this method for a variant that does not require a prefix.

        Parameter 'value' is the value of the attribute.

        """

        if type(args[1]) == type(True): return _libsbml.XMLOutputStream_writeAttributeBool(self, *args)


        return _libsbml.XMLOutputStream_writeAttribute(self, *args)


    def writeXMLDecl(self):
        """
        writeXMLDecl(XMLOutputStream self)


        Writes a standard XML declaration to this output stream.

        The XML declaration has the form

          <?xml version='1.0' encoding='UTF-8'?>

        Note that the SBML specifications require the use of UTF-8 encoding
        and version 1.0, so for SBML documents, the above is the standard XML
        declaration.

        """
        return _libsbml.XMLOutputStream_writeXMLDecl(self)


    def writeComment(self, programName, programVersion, writeTimestamp=True):
        """
        writeComment(XMLOutputStream self, string programName, string programVersion, bool writeTimestamp=True)
        writeComment(XMLOutputStream self, string programName, string programVersion)


        Writes an XML comment with the name and version of this program.

        The XML comment has the following form:

          <!-- Created by <program name> version <program version>
          on yyyy-MM-dd HH:mm with libSBML version <libsbml version>. -->

        See the class constructor for more information about this program
        comment.

        Parameter 'programName' is an optional program name to write as a
        comment in the output stream.

        Parameter 'programVersion' is an optional version identification
        string to write as a comment in the output stream.

        Parameter 'writeTimestamp' is an optional flag indicating that a
        timestamp should be written.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        return _libsbml.XMLOutputStream_writeComment(self, programName, programVersion, writeTimestamp)


    def downIndent(self):
        """
        downIndent(XMLOutputStream self)


        Decreases the indentation level for this XMLOutputStream.

        LibSBML tries to produce human-readable XML output by automatically
        indenting the bodies of elements.  Callers can manually control
        indentation further by using the XMLOutputStream.upIndent() and
        XMLOutputStream.downIndent() methods to increase and decrease,
        respectively, the current level of indentation in the XML output.

        See also upIndent().

        """
        return _libsbml.XMLOutputStream_downIndent(self)


    def upIndent(self):
        """
        upIndent(XMLOutputStream self)


        Increases the indentation level for this XMLOutputStream.

        LibSBML tries to produce human-readable XML output by automatically
        indenting the bodies of elements.  Callers can manually control
        indentation further by using the XMLOutputStream.upIndent() and
        XMLOutputStream.downIndent() methods to increase and decrease,
        respectively, the current level of indentation in the XML output.

        See also downIndent().

        """
        return _libsbml.XMLOutputStream_upIndent(self)


    def getSBMLNamespaces(self):
        """
        getSBMLNamespaces(XMLOutputStream self) -> SBMLNamespaces


        Returns the SBMLNamespaces object attached to this output stream.

        Returns the SBMLNamespaces object, or 'None' if none has been set.

        """
        return _libsbml.XMLOutputStream_getSBMLNamespaces(self)


    def setSBMLNamespaces(self, sbmlns):
        """
        setSBMLNamespaces(XMLOutputStream self, SBMLNamespaces sbmlns)


        Sets the SBMLNamespaces object associated with this output stream.

        Parameter 'sbmlns' is the namespace object.

        """
        return _libsbml.XMLOutputStream_setSBMLNamespaces(self, sbmlns)


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


        Returns a boolean, whether the output stream will write an XML comment
        at the top of the file. (Enabled by default.)

        """
        return _libsbml.XMLOutputStream_getWriteComment()

    getWriteComment = staticmethod(getWriteComment)

    def setWriteComment(writeComment):
        """
        setWriteComment(bool writeComment)


        sets a flag, whether the output stream will write an XML comment at
        the top of the file. (Enabled by default.)

        Parameter 'writeComment' is the flag.

        """
        return _libsbml.XMLOutputStream_setWriteComment(writeComment)

    setWriteComment = staticmethod(setWriteComment)

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


        Returns a boolean, whether the output stream will write an XML comment
        with a timestamp at the top of the file. (Enabled by default.)

        """
        return _libsbml.XMLOutputStream_getWriteTimestamp()

    getWriteTimestamp = staticmethod(getWriteTimestamp)

    def setWriteTimestamp(writeTimestamp):
        """
        setWriteTimestamp(bool writeTimestamp)


        sets a flag, whether the output stream will write an XML comment with
        a timestamp at the top of the file. (Enabled by default.)

        Parameter 'writeTimestamp' is the flag.

        """
        return _libsbml.XMLOutputStream_setWriteTimestamp(writeTimestamp)

    setWriteTimestamp = staticmethod(setWriteTimestamp)

    def getLibraryName():
        """
        getLibraryName() -> string


        Returns the name of the library to be used in comments ('libSBML' by
        default).

        """
        return _libsbml.XMLOutputStream_getLibraryName()

    getLibraryName = staticmethod(getLibraryName)

    def setLibraryName(libraryName):
        """
        setLibraryName(string libraryName)


        sets the name of the library writing the XML Parameter 'libraryName'
        is the name of the library to be used in comments.

        """
        return _libsbml.XMLOutputStream_setLibraryName(libraryName)

    setLibraryName = staticmethod(setLibraryName)

    def getLibraryVersion():
        """
        getLibraryVersion() -> string


        Returns a string representing the version of the library writing the
        output. This is the value of getLibSBMLDottedVersion() by default.

        """
        return _libsbml.XMLOutputStream_getLibraryVersion()

    getLibraryVersion = staticmethod(getLibraryVersion)

    def setLibraryVersion(libraryVersion):
        """
        setLibraryVersion(string libraryVersion)


        sets the name of the library writing the output

        Parameter 'libraryVersion' is the version information as string.

        """
        return _libsbml.XMLOutputStream_setLibraryVersion(libraryVersion)

    setLibraryVersion = staticmethod(setLibraryVersion)

    def getIndent(self):
        """
        getIndent(XMLOutputStream self) -> unsigned int


        Internal implementation method.

        """
        return _libsbml.XMLOutputStream_getIndent(self)


    def setIndent(self, indent):
        """
        setIndent(XMLOutputStream self, unsigned int indent)


        Internal implementation method.

        """
        return _libsbml.XMLOutputStream_setIndent(self, indent)


    def writeAttributeBool(self, *args):
        """
        writeAttributeBool(XMLOutputStream self, string name, bool const & value)
        writeAttributeBool(XMLOutputStream self, XMLTriple name, bool const & value)

        @internal
        """
        return _libsbml.XMLOutputStream_writeAttributeBool(self, *args)


    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

XMLOutputStream_swigregister = _libsbml.XMLOutputStream_swigregister
XMLOutputStream_swigregister(XMLOutputStream)

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


    Returns a boolean, whether the output stream will write an XML comment
    at the top of the file. (Enabled by default.)

    """
    return _libsbml.XMLOutputStream_getWriteComment()

def XMLOutputStream_setWriteComment(writeComment):
    """
    XMLOutputStream_setWriteComment(bool writeComment)


    sets a flag, whether the output stream will write an XML comment at
    the top of the file. (Enabled by default.)

    Parameter 'writeComment' is the flag.

    """
    return _libsbml.XMLOutputStream_setWriteComment(writeComment)

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


    Returns a boolean, whether the output stream will write an XML comment
    with a timestamp at the top of the file. (Enabled by default.)

    """
    return _libsbml.XMLOutputStream_getWriteTimestamp()

def XMLOutputStream_setWriteTimestamp(writeTimestamp):
    """
    XMLOutputStream_setWriteTimestamp(bool writeTimestamp)


    sets a flag, whether the output stream will write an XML comment with
    a timestamp at the top of the file. (Enabled by default.)

    Parameter 'writeTimestamp' is the flag.

    """
    return _libsbml.XMLOutputStream_setWriteTimestamp(writeTimestamp)

def XMLOutputStream_getLibraryName():
    """
    XMLOutputStream_getLibraryName() -> string


    Returns the name of the library to be used in comments ('libSBML' by
    default).

    """
    return _libsbml.XMLOutputStream_getLibraryName()

def XMLOutputStream_setLibraryName(libraryName):
    """
    XMLOutputStream_setLibraryName(string libraryName)


    sets the name of the library writing the XML Parameter 'libraryName'
    is the name of the library to be used in comments.

    """
    return _libsbml.XMLOutputStream_setLibraryName(libraryName)

def XMLOutputStream_getLibraryVersion():
    """
    XMLOutputStream_getLibraryVersion() -> string


    Returns a string representing the version of the library writing the
    output. This is the value of getLibSBMLDottedVersion() by default.

    """
    return _libsbml.XMLOutputStream_getLibraryVersion()

def XMLOutputStream_setLibraryVersion(libraryVersion):
    """
    XMLOutputStream_setLibraryVersion(string libraryVersion)


    sets the name of the library writing the output

    Parameter 'libraryVersion' is the version information as string.

    """
    return _libsbml.XMLOutputStream_setLibraryVersion(libraryVersion)

class XMLOwningOutputStringStream(_object):
    """Proxy of C++ XMLOwningOutputStringStream class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, XMLOwningOutputStringStream, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, XMLOwningOutputStringStream, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(XMLOwningOutputStringStream self, string encoding, bool writeXMLDecl=True, string programName, string programVersion) -> XMLOwningOutputStringStream
        __init__(XMLOwningOutputStringStream self, string encoding, bool writeXMLDecl=True, string programName) -> XMLOwningOutputStringStream
        __init__(XMLOwningOutputStringStream self, string encoding, bool writeXMLDecl=True) -> XMLOwningOutputStringStream
        __init__(XMLOwningOutputStringStream self, string encoding) -> XMLOwningOutputStringStream
        __init__(XMLOwningOutputStringStream self) -> XMLOwningOutputStringStream


        Internal implementation method.

        """
        this = _libsbml.new_XMLOwningOutputStringStream(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_XMLOwningOutputStringStream
    __del__ = lambda self: None
XMLOwningOutputStringStream_swigregister = _libsbml.XMLOwningOutputStringStream_swigregister
XMLOwningOutputStringStream_swigregister(XMLOwningOutputStringStream)

class XMLOwningOutputFileStream(_object):
    """Proxy of C++ XMLOwningOutputFileStream class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, XMLOwningOutputFileStream, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, XMLOwningOutputFileStream, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(XMLOwningOutputFileStream self, string filename, string encoding, bool writeXMLDecl=True, string programName, string programVersion) -> XMLOwningOutputFileStream
        __init__(XMLOwningOutputFileStream self, string filename, string encoding, bool writeXMLDecl=True, string programName) -> XMLOwningOutputFileStream
        __init__(XMLOwningOutputFileStream self, string filename, string encoding, bool writeXMLDecl=True) -> XMLOwningOutputFileStream
        __init__(XMLOwningOutputFileStream self, string filename, string encoding) -> XMLOwningOutputFileStream
        __init__(XMLOwningOutputFileStream self, string filename) -> XMLOwningOutputFileStream


        Internal implementation method.

        """
        this = _libsbml.new_XMLOwningOutputFileStream(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_XMLOwningOutputFileStream
    __del__ = lambda self: None
XMLOwningOutputFileStream_swigregister = _libsbml.XMLOwningOutputFileStream_swigregister
XMLOwningOutputFileStream_swigregister(XMLOwningOutputFileStream)

class XMLInputStream(_object):
    """

    An interface to an XML input stream.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    SBML content is serialized using XML; the resulting data can be
    stored and read to/from a file or data stream.  Low-level XML parsers
    such as Xerces provide facilities to read XML data.  To permit the use
    of different XML parsers (Xerces, Expat or libxml2), libSBML
    implements an abstraction layer.  XMLInputStream and XMLOutputStream
    are two parts of that abstraction layer.

    XMLInputStream is an interface to a file or text string containing
    XML. It wraps the content to be read, as well as the low-level XML
    parser to be used and an XMLErrorLog to record errors and other issues
    (if any arise). Internally, the content will be in the form of either
    a pointer to a file name or a character string; XMLInputStream knows
    the form of the content and acts appropriately.  Other libSBML object
    classes use XMLInputStream as their interface for all read operations
    on the XML data. XMLInputStream provides the functionality to extract
    data in the form of XMLToken objects.  It logs any errors encountered
    while reading.  It also keeps track of whether a read operation has
    failed irrecoverably or determines whether it is safe to continue
    reading.

    SBMLNamespaces objects can be associated with an XMLInputStream; this
    facilitates logging errors related to reading XML attributes and
    elements that may only be relevant to particular Level and Version
    combinations of SBML.

    Note: The convenience of the XMLInputStream and XMLOutputStream
    abstraction may be useful for developers interested in creating
    parsers for other XML formats besides SBML.  It can provide developers
    with a layer above more basic XML parsers, as well as some useful
    programmatic elements such as XMLToken, XMLError, etc.

    See also XMLOutputStream.

    """

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, XMLInputStream, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, XMLInputStream, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(XMLInputStream self, char const * content, bool isFile=True, string library, XMLErrorLog errorLog=None) -> XMLInputStream
        __init__(XMLInputStream self, char const * content, bool isFile=True, string library) -> XMLInputStream
        __init__(XMLInputStream self, char const * content, bool isFile=True) -> XMLInputStream
        __init__(XMLInputStream self, char const * content) -> XMLInputStream


        Creates a new XMLInputStream.

        @param content the source of the stream.

        @param isFile a boolean flag to indicate whether @p content is a file
        name.  If @c true, @p content is assumed to be the file from which the
        XML content is to be read.  If @c false, @p content is taken to be a
        string that @em is the content to be read.

        @param library the name of the parser library to use.

        @param errorLog the XMLErrorLog object to use.

        @htmlinclude warn-default-args-in-docs.html

        """
        this = _libsbml.new_XMLInputStream(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_XMLInputStream
    __del__ = lambda self: None

    def getEncoding(self):
        """
        getEncoding(XMLInputStream self) -> string


        Returns the encoding of the XML stream.

        The encoding is indicated by the xml declaration at the beginning of
        an XML document or data stream.  The form of this declaration is

          <?xml version='1.0' encoding='UTF-8'?>

        Note that the SBML specifications require the use of UTF-8 encoding,
        so for SBML documents, the value returned by this method will always
        be the string 'UTF-8'.

        Returns the encoding of the XML stream.

        See also getVersion().

        """
        return _libsbml.XMLInputStream_getEncoding(self)


    def getVersion(self):
        """
        getVersion(XMLInputStream self) -> string


        Returns the version of the XML stream.

        The version is indicated by the xml declaration at the beginning of an
        XML document or data stream.  The form of this declaration is

           <?xml version='1.0' encoding='UTF-8'?>

        Note that the SBML specifications require the use of version 1.0, so
        for SBML documents, the value returned by this method will always be
        the string '1.0'.

        Returns the version of the XML stream.

        See also getEncoding().

        """
        return _libsbml.XMLInputStream_getVersion(self)


    def getErrorLog(self):
        """
        getErrorLog(XMLInputStream self) -> XMLErrorLog


        Returns the XMLErrorLog used to log parsing problems.

        Returns the XMLErrorLog used to log XML parse errors and other
        validation errors (and messages).

        """
        return _libsbml.XMLInputStream_getErrorLog(self)


    def isEOF(self):
        """
        isEOF(XMLInputStream self) -> bool


        Returns 'True' if end of file (stream) has been reached.

        Returns 'True' if end of file (stream) has been reached, 'False'
        otherwise.

        """
        return _libsbml.XMLInputStream_isEOF(self)


    def isError(self):
        """
        isError(XMLInputStream self) -> bool


        Returns 'True' if a fatal error occurred while reading from this
        stream.

        Returns 'True' if a fatal error occurred while reading from this
        stream.

        """
        return _libsbml.XMLInputStream_isError(self)


    def isGood(self):
        """
        isGood(XMLInputStream self) -> bool


        Returns 'True' if the stream is in a good state.

        The definition of 'good state' is that isEOF() and isError() both
        return 'False.'

        Returns 'True' if the stream is in a good state, 'False' otherwise.

        """
        return _libsbml.XMLInputStream_isGood(self)


    def next(self):
        """
        next(XMLInputStream self) -> XMLToken


        Returns the next token on this XML input stream.

        The token is consumed in the process.

        Returns the next XMLToken, or an EOF token (i.e., XMLToken.isEOF() ==
        true).

        See also peek().

        """
        return _libsbml.XMLInputStream_next(self)


    def peek(self):
        """
        peek(XMLInputStream self) -> XMLToken


        Returns the next token without consuming it.

        A subsequent call to either peek() or next() will return the same
        token.

        Returns the next XMLToken or EOF (XMLToken.isEOF() == true).

        See also next().

        """
        return _libsbml.XMLInputStream_peek(self)


    def skipPastEnd(self, element):
        """
        skipPastEnd(XMLInputStream self, XMLToken element)


        Consume zero or more tokens up to and including the corresponding end
        element or EOF.

        Parameter 'element' is the element whose end will be sought in the
        input stream.

        """
        return _libsbml.XMLInputStream_skipPastEnd(self, element)


    def skipText(self):
        """
        skipText(XMLInputStream self)


        Consume zero or more tokens up to but not including the next XML
        element or EOF.

        """
        return _libsbml.XMLInputStream_skipText(self)


    def setErrorLog(self, log):
        """
        setErrorLog(XMLInputStream self, XMLErrorLog log) -> int


        Sets the XMLErrorLog this stream will use to log errors.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.XMLInputStream_setErrorLog(self, log)


    def toString(self):
        """
        toString(XMLInputStream self) -> string


        Prints a string representation of the underlying token stream.

        Returns a string representing the underlying XML token stream.

        Note: This method is intended for debugging purposes.

        """
        return _libsbml.XMLInputStream_toString(self)


    def getSBMLNamespaces(self):
        """
        getSBMLNamespaces(XMLInputStream self) -> SBMLNamespaces


        Returns the SBMLNamespaces object attached to this XMLInputStream.

        Returns the SBMLNamespaces object or 'None' if none has been set.

        """
        return _libsbml.XMLInputStream_getSBMLNamespaces(self)


    def setSBMLNamespaces(self, sbmlns):
        """
        setSBMLNamespaces(XMLInputStream self, SBMLNamespaces sbmlns)


        Sets the SBML namespaces associated with this XML input stream.

        This allows this stream to reference the available SBML namespaces
        being read.

        Parameter 'sbmlns' is the list of namespaces to use.

        """
        return _libsbml.XMLInputStream_setSBMLNamespaces(self, sbmlns)


    def determineNumberChildren(self, *args):
        """
        determineNumberChildren(XMLInputStream self, string elementName) -> unsigned int
        determineNumberChildren(XMLInputStream self) -> unsigned int


        Returns the number of child tokens of the given element in this
        stream.

        This method allows information from the input stream to be determined
        without the need to actually read and consume the tokens in the
        stream. It returns the number of child elements of the element
        represented by the 'elementName', i.e., the number of child elements
        encountered before the closing tag for the 'elementName' supplied.

        If no 'elementName' is supplied or it is an empty string, then as a
        special case, this method assumes the element is a MathML apply
        element followed by a function name.

        Parameter 'elementName' is a string representing the name of the
        element for which the number of children are to be determined.

        Returns a long integer giving the number of children of the
        'elementName' specified.

        Note: This method assumes the stream has been read up to and including
        the element 'elementName'.

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        return _libsbml.XMLInputStream_determineNumberChildren(self, *args)


    def determineNumSpecificChildren(self, childName, container):
        """
        determineNumSpecificChildren(XMLInputStream self, string childName, string container) -> unsigned int


        Returns the number of child tokens of the specified type within a
        given container element.

        This method allows information from the input stream to be determined
        without the need to actually read and consume the tokens in the
        stream. It returns the number of child elements of the 'childName'
        element within the element specified by 'container'.  In other words,
        it counts the number of 'childName' elements encountered before the
        closing tag for the 'container' supplied.

        Parameter 'childName' is a string representing the name of the child
        element whose number is to be determined.

        Parameter 'container' is a string representing the name of the element
        for which the number of children are to be determined.

        Returns a long integer giving the number of children of type
        'childName' within the 'container' element.

        Note: This method assumes the stream has been read up to and including
        the element 'container'.

        """
        return _libsbml.XMLInputStream_determineNumSpecificChildren(self, childName, container)


    def containsChild(self, childName, container):
        """
        containsChild(XMLInputStream self, string childName, string container) -> bool


        Predicate returning 'True' if a child token of the specified type
        occurs  within a given container element.

        This method allows information from the input stream to be determined
        without the need to actually read and consume the tokens in the
        stream. It returns 'True' if the 'childName' element occurs at any
        point within the element specified by 'container'.

        Parameter 'childName' is a string representing the name of the child
        element whose presence is to be determined.

        Parameter 'container' is a string representing the name of the element
        for which the presence of the child element is to be determined.

        Returns boolean 'True' if a child of type 'childName' occurs within
        the 'container' element, 'False' otherwise.

        Note: This method assumes the stream has been read up to and including
        the element 'container'.

        """
        return _libsbml.XMLInputStream_containsChild(self, childName, container)

XMLInputStream_swigregister = _libsbml.XMLInputStream_swigregister
XMLInputStream_swigregister(XMLInputStream)

XMLUnknownError = _libsbml.XMLUnknownError
XMLOutOfMemory = _libsbml.XMLOutOfMemory
XMLFileUnreadable = _libsbml.XMLFileUnreadable
XMLFileUnwritable = _libsbml.XMLFileUnwritable
XMLFileOperationError = _libsbml.XMLFileOperationError
XMLNetworkAccessError = _libsbml.XMLNetworkAccessError
InternalXMLParserError = _libsbml.InternalXMLParserError
UnrecognizedXMLParserCode = _libsbml.UnrecognizedXMLParserCode
XMLTranscoderError = _libsbml.XMLTranscoderError
MissingXMLDecl = _libsbml.MissingXMLDecl
MissingXMLEncoding = _libsbml.MissingXMLEncoding
BadXMLDecl = _libsbml.BadXMLDecl
BadXMLDOCTYPE = _libsbml.BadXMLDOCTYPE
InvalidCharInXML = _libsbml.InvalidCharInXML
BadlyFormedXML = _libsbml.BadlyFormedXML
UnclosedXMLToken = _libsbml.UnclosedXMLToken
InvalidXMLConstruct = _libsbml.InvalidXMLConstruct
XMLTagMismatch = _libsbml.XMLTagMismatch
DuplicateXMLAttribute = _libsbml.DuplicateXMLAttribute
UndefinedXMLEntity = _libsbml.UndefinedXMLEntity
BadProcessingInstruction = _libsbml.BadProcessingInstruction
BadXMLPrefix = _libsbml.BadXMLPrefix
BadXMLPrefixValue = _libsbml.BadXMLPrefixValue
MissingXMLRequiredAttribute = _libsbml.MissingXMLRequiredAttribute
XMLAttributeTypeMismatch = _libsbml.XMLAttributeTypeMismatch
XMLBadUTF8Content = _libsbml.XMLBadUTF8Content
MissingXMLAttributeValue = _libsbml.MissingXMLAttributeValue
BadXMLAttributeValue = _libsbml.BadXMLAttributeValue
BadXMLAttribute = _libsbml.BadXMLAttribute
UnrecognizedXMLElement = _libsbml.UnrecognizedXMLElement
BadXMLComment = _libsbml.BadXMLComment
BadXMLDeclLocation = _libsbml.BadXMLDeclLocation
XMLUnexpectedEOF = _libsbml.XMLUnexpectedEOF
BadXMLIDValue = _libsbml.BadXMLIDValue
BadXMLIDRef = _libsbml.BadXMLIDRef
UninterpretableXMLContent = _libsbml.UninterpretableXMLContent
BadXMLDocumentStructure = _libsbml.BadXMLDocumentStructure
InvalidAfterXMLContent = _libsbml.InvalidAfterXMLContent
XMLExpectedQuotedString = _libsbml.XMLExpectedQuotedString
XMLEmptyValueNotPermitted = _libsbml.XMLEmptyValueNotPermitted
XMLBadNumber = _libsbml.XMLBadNumber
XMLBadColon = _libsbml.XMLBadColon
MissingXMLElements = _libsbml.MissingXMLElements
XMLContentEmpty = _libsbml.XMLContentEmpty
XMLErrorCodesUpperBound = _libsbml.XMLErrorCodesUpperBound
LIBSBML_CAT_INTERNAL = _libsbml.LIBSBML_CAT_INTERNAL
LIBSBML_CAT_SYSTEM = _libsbml.LIBSBML_CAT_SYSTEM
LIBSBML_CAT_XML = _libsbml.LIBSBML_CAT_XML
LIBSBML_SEV_INFO = _libsbml.LIBSBML_SEV_INFO
LIBSBML_SEV_WARNING = _libsbml.LIBSBML_SEV_WARNING
LIBSBML_SEV_ERROR = _libsbml.LIBSBML_SEV_ERROR
LIBSBML_SEV_FATAL = _libsbml.LIBSBML_SEV_FATAL
LIBSBML_OVERRIDE_DISABLED = _libsbml.LIBSBML_OVERRIDE_DISABLED
LIBSBML_OVERRIDE_DONT_LOG = _libsbml.LIBSBML_OVERRIDE_DONT_LOG
LIBSBML_OVERRIDE_WARNING = _libsbml.LIBSBML_OVERRIDE_WARNING
LIBSBML_OVERRIDE_ERROR = _libsbml.LIBSBML_OVERRIDE_ERROR
class XMLError(_object):
    """

    XML-level errors, warnings and other diagnostics.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    LibSBML can be configured to use any of a number of XML parsers; at
    the time of this writing, libSBML supports Xerces versions 2.4 through
    3.1, Expat version 1.95.x and higher, and libxml2 version 2.6.16 and
    higher. These parsers each report different status codes for the
    various exceptions that can occur during XML processing.  The XMLError
    object class abstracts away from the particular diagnostics reported
    by the different parsers and presents a single uniform interface and
    set of status codes, along with operations for manipulating the error
    objects.

    When the libSBML XML parser layer encounters an error in the XML
    content being processed, or when there is something else wrong (such
    as an out-of-memory condition), the problems are reported as XMLError
    objects. Each XMLError object instance has an identification number
    that identifies the nature of the problem. This error identifier is
    one of the constants listed in the next section below. Applications
    can use the error identifiers as a means of recognizing the error
    encountered and changing their behavior if desired.

    Integer error codes are useful for software, but not so much for
    telling humans what happened.  For this reason, XMLError also provides
    two text messages describing the nature of the error.  These messages
    are accessible by means of the methods XMLError.getShortMessage() and
    XMLError.getMessage().  The method XMLError.getShortMessage() returns
    a very brief synopsis of the warning or error condition, whereas
    XMLError.getMessage() returns a longer explanation.  These text
    strings are suitable for displaying to human users.

    Each XMLError object also contains a category code; its value may be
    retrieved using the method XMLError.getCategory().  Category values
    are drawn from a set of constants whose names begin with the
    characters 'LIBSBML_CAT_,' described below. Categories are used by
    libSBML to provide more information to calling programs about the
    nature of a given error.

    In addition to category codes, each XMLError object also has a
    severity code; its value may be retrieved using the method
    XMLError.getSeverity().  Severity code values are drawn from a set of
    constants whose names begin with the characters 'LIBSBML_SEV_,'
    described below. Severity levels range from informational
    (LIBSBML_SEV_INFO) to fatal errors (LIBSBML_SEV_FATAL).

    Finally, XMLError objects record the line and column near where the
    problem occurred in the XML content.  The values can be retrieved
    using the methods XMLError.getLine() and XMLError.getColumn().  We say
    'near where the problem occurred', because many factors affect how
    accurate the line/column information ultimately is.  For example,
    sometimes, the underlying XML parsers can only report such information
    for the parent XML element where an error occurs, and not for the
    specific point where the problem occurs.  In other situations, some
    parsers report invalid line and/or column numbers altogether.  If this
    occurs, libSBML sets the line and/or column number in the XMLError
    object to either 0 or the value of the maximum unsigned long integer
    representable on the platform where libSBML is running.  The
    probability that a true line or column number in an SBML model would
    equal this value is vanishingly small; thus, if an application
    encounters these values in an XMLError object, it can assume no valid
    line/column number could be provided by libSBML in that situation.

    <center>

      +-----------------------------+---------------------------------------------------------------+----------+----------+
      | Enumerator                  | Meaning                                                       | Category | Severity |
      +-----------------------------+---------------------------------------------------------------+----------+----------+
      | XMLUnknownError             | Unrecognized error encountered internally                     | INTERNAL | FATAL    |
      | XMLOutOfMemory              | Out of memory                                                 | SYSTEM   | FATAL    |
      | XMLFileUnreadable           | File unreadable                                               | SYSTEM   | ERROR    |
      | XMLFileUnwritable           | File unwritable                                               | SYSTEM   | ERROR    |
      | XMLFileOperationError       | Error encountered while attempting file operation             | SYSTEM   | ERROR    |
      | XMLNetworkAccessError       | Network access error                                          | SYSTEM   | ERROR    |
      | InternalXMLParserError      | Internal XML parser state error                               | INTERNAL | FATAL    |
      | UnrecognizedXMLParserCode   | XML parser returned an unrecognized error code                | INTERNAL | FATAL    |
      | XMLTranscoderError          | Character transcoder error                                    | INTERNAL | FATAL    |
      | MissingXMLDecl              | Missing XML declaration at beginning of XML input             | XML      | ERROR    |
      | MissingXMLEncoding          | Missing encoding attribute in XML declaration                 | XML      | ERROR    |
      | BadXMLDecl                  | Invalid or unrecognized XML declaration or XML encoding       | XML      | ERROR    |
      | BadXMLDOCTYPE               | Invalid, malformed or unrecognized XML DOCTYPE declaration    | XML      | ERROR    |
      | InvalidCharInXML            | Invalid character in XML content                              | XML      | ERROR    |
      | BadlyFormedXML              | XML content is not well-formed                                | XML      | ERROR    |
      | UnclosedXMLToken            | Unclosed XML token                                            | XML      | ERROR    |
      | InvalidXMLConstruct         | XML construct is invalid or not permitted                     | XML      | ERROR    |
      | XMLTagMismatch              | Element tag mismatch or missing tag                           | XML      | ERROR    |
      | DuplicateXMLAttribute       | Duplicate XML attribute                                       | XML      | ERROR    |
      | UndefinedXMLEntity          | Undefined XML entity                                          | XML      | ERROR    |
      | BadProcessingInstruction    | Invalid, malformed or unrecognized XML processing instruction | XML      | ERROR    |
      | BadXMLPrefix                | Invalid or undefined XML namespace prefix                     | XML      | ERROR    |
      | BadXMLPrefixValue           | Invalid XML namespace prefix value                            | XML      | ERROR    |
      | MissingXMLRequiredAttribute | Missing a required XML attribute                              | XML      | ERROR    |
      | XMLAttributeTypeMismatch    | Data type mismatch for the value of an attribute              | XML      | ERROR    |
      | XMLBadUTF8Content           | Invalid UTF8 content                                          | XML      | ERROR    |
      | MissingXMLAttributeValue    | Missing or improperly formed attribute value                  | XML      | ERROR    |
      | BadXMLAttributeValue        | Invalid or unrecognizable attribute value                     | XML      | ERROR    |
      | BadXMLAttribute             | Invalid, unrecognized or malformed attribute                  | XML      | ERROR    |
      | UnrecognizedXMLElement      | Element either not recognized or not permitted                | XML      | ERROR    |
      | BadXMLComment               | Badly formed XML comment                                      | XML      | ERROR    |
      | BadXMLDeclLocation          | XML declaration not permitted in this location                | XML      | ERROR    |
      | XMLUnexpectedEOF            | Reached end of input unexpectedly                             | XML      | ERROR    |
      | BadXMLIDValue               | Value is invalid for XML ID, or has already been used         | XML      | ERROR    |
      | BadXMLIDRef                 | XML ID value was never declared                               | XML      | ERROR    |
      | UninterpretableXMLContent   | Unable to interpret content                                   | XML      | ERROR    |
      | BadXMLDocumentStructure     | Bad XML document structure                                    | XML      | ERROR    |
      | InvalidAfterXMLContent      | Encountered invalid content after expected content            | XML      | ERROR    |
      | XMLExpectedQuotedString     | Expected to find a quoted string                              | XML      | ERROR    |
      | XMLEmptyValueNotPermitted   | An empty value is not permitted in this context               | XML      | ERROR    |
      | XMLBadNumber                | Invalid or unrecognized number                                | XML      | ERROR    |
      | XMLBadColon                 | Colon characters are invalid in this context                  | XML      | ERROR    |
      | MissingXMLElements          | One or more expected elements are missing                     | XML      | ERROR    |
      | XMLContentEmpty             | Main XML content is empty                                     | XML      | ERROR    |
      +-----------------------------+---------------------------------------------------------------+----------+----------+

    </center>

    <center>

      +----------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
      | Enumerator           | Meaning                                                                                                                                                                                                              |
      +----------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
      | LIBSBML_CAT_INTERNAL | A problem involving the libSBML software itself or the underlying XML parser.  This almost certainly indicates a software defect (i.e., bug) in libSBML.  Please report instances of this to the libSBML developers. |
      | LIBSBML_CAT_SYSTEM   | A problem reported by the operating system, such as an inability to read or write a file.  This indicates something that is not a program error but is outside of the control of libSBML.                            |
      | LIBSBML_CAT_XML      | A problem in the XML content itself.  This usually arises from malformed XML or the use of constructs not permitted in SBML.                                                                                         |
      +----------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+

    </center>

    <center>

      +---------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
      | Enumerator          | Meaning                                                                                                                                                                                       |
      +---------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
      | LIBSBML_SEV_INFO    | The error is actually informational and not necessarily a serious problem.                                                                                                                    |
      | LIBSBML_SEV_WARNING | The error object represents a problem that is not serious enough to necessarily stop the problem, but applications should take note of the problem and evaluate what its implications may be. |
      | LIBSBML_SEV_ERROR   | The error object represents a serious error.  The application may continue running but it is unlikely to be able to continue processing the same XML file or data stream.                     |
      | LIBSBML_SEV_FATAL   | A serious error occurred, such as an out-of-memory condition, and the software should terminate immediately.                                                                                  |
      +---------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+

    </center>

    """

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, XMLError, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, XMLError, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(XMLError self, int const errorId=0, string details, unsigned int const line=0, unsigned int const column=0, unsigned int const severity=LIBSBML_SEV_FATAL, unsigned int const category=LIBSBML_CAT_INTERNAL) -> XMLError
        __init__(XMLError self, int const errorId=0, string details, unsigned int const line=0, unsigned int const column=0, unsigned int const severity=LIBSBML_SEV_FATAL) -> XMLError
        __init__(XMLError self, int const errorId=0, string details, unsigned int const line=0, unsigned int const column=0) -> XMLError
        __init__(XMLError self, int const errorId=0, string details, unsigned int const line=0) -> XMLError
        __init__(XMLError self, int const errorId=0, string details) -> XMLError
        __init__(XMLError self, int const errorId=0) -> XMLError
        __init__(XMLError self) -> XMLError
        __init__(XMLError self, XMLError orig) -> XMLError


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            XMLError(XMLError orig)

        Copy constructor; creates a copy of this XMLError.

        'orig' the XMLError object to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            XMLError(  int errorId           = 0 , string details  = '' ,
        long line     = 0 ,  long column   = 0 ,  long severity =
        LIBSBML_SEV_FATAL ,  long category = LIBSBML_CAT_INTERNAL )

        Creates a new XMLError to report that something occurred during XML
        processing.

        XMLError objects have identification numbers to indicate the nature of
        the exception.  These numbers are defined as longeger constants in the
        file 'libsbmlConstants.java'.  See the top of this documentation for a
        table listing the possible values and their meanings.  The argument
        'errorId' to this constructor can be (but does not have to be) a value
        from this set of constants.  If it is one of the predefined error
        identifiers, the XMLError class assumes the error is a low-level
        system or XML layer error and prepends a built-in, predefined error
        message to any string passed in the argument 'details' to this
        constructor.  In addition, all the predefined error identifiers have
        associated values for the 'severity' and 'category' codes, and these
        fields are filled-in as well.

        If the error identifier 'errorId' is a number greater than 9999, this
        constructor assumes that the error was generated from another part of
        the software, and does not do additional filling in of values beyond
        the defaults in the constructor itself.  This allows XMLError to serve
        as a base class for other errors (and is used in this way elsewhere in
        libSBML).  Callers should fill in all the parameters with suitable
        values if generating errors with codes greater than 9999 to make
        maximum use of the XMLError facilities.

        As mentioned above,  there are additional constants defined for
        standard severity and standard category codes, and every predefined
        error in libSBML has an associated value for severity and category
        taken from these predefined sets.  These constants have symbol names
        prefixed with LIBSBML_SEV_ and LIBSBML_CAT_, respectively.  If the
        value of 'errorId' is one of the standard error codes, callers do not
        need to fill in 'severity' and 'category' in a call to this
        constructor.  Conversely, if 'errorId' is not an existing XML-level
        error code, callers can use other values for 'severity' and
        'category'.

        Parameter 'errorId' is a long integer, the identification number of
        the error.

        Parameter 'details' is a string containing additional details about
        the error. If the error code in 'errorId' is one that is recognized by
        XMLError, the given message is appended to a predefined message
        associated with the given code.  If the error code is not recognized,
        the message is stored as-is as the text of the error.

        Parameter 'line' is a long integer, the line number at which the error
        occured.

        Parameter 'column' is a long integer, the column number at which the
        error occured.

        Parameter 'severity' is an integer indicating severity of the error.

        Parameter 'category' is an integer indicating the category to which
        the error belongs.

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        this = _libsbml.new_XMLError(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_XMLError
    __del__ = lambda self: None

    def getErrorId(self):
        """
        getErrorId(XMLError self) -> unsigned int


        Returns the identifier of this error.

        Returns the error code for this error.

        See also getMessage(), getShortMessage(), getCategory(),
        getSeverity().

        """
        return _libsbml.XMLError_getErrorId(self)


    def getMessage(self):
        """
        getMessage(XMLError self) -> string


        Returns the message text of this error.

        The message associated with an error object describes the nature of
        the problem.  The message returned by this method is generally longer
        and clearer than the message returned by XMLError.getShortMessage(),
        but not in all cases.

        Callers may use XMLError.getCategory() and XMLError.getSeverity() to
        obtain additional information about the nature and severity of the
        problem.

        Returns the message text.

        See also getErrorId(), getShortMessage(), getCategory(),
        getSeverity().

        """
        return _libsbml.XMLError_getMessage(self)


    def getShortMessage(self):
        """
        getShortMessage(XMLError self) -> string


        Returns a brief message for this error.

        This is an alternative error message that, in general, is as short as
        the authors could make it.  However, brevity is often inversely
        proportional to clarity, so this short message may not be sufficiently
        informative to understand the nature of the error.  Calling
        applications may wish to check XMLError.getMessage() in addition or
        instead.

        Returns the short error message text.

        See also getErrorId(), getMessage(), getCategory(), getSeverity().

        """
        return _libsbml.XMLError_getShortMessage(self)


    def getLine(self):
        """
        getLine(XMLError self) -> unsigned int


        Returns the line number in the XML input near where the error, warning
        or other diagnostic occurred.

        We say 'near where the problem occurred', because many factors affect
        how accurate the line/column information ultimately is.  For example,
        sometimes, the underlying XML parsers can only report such information
        for the parent XML element where an error occurs, and not for the
        specific point where the problem occurs.  In other situations, some
        parsers report invalid line and/or column numbers altogether.  If this
        occurs, libSBML sets the line and/or column number in the XMLError
        object to either 0 or the value of the maximum unsigned long integer
        representable on the platform where libSBML is running. The
        probability that a true line or column number in an SBML model would
        equal this value is vanishingly small; thus, if an application
        encounters these values in an XMLError object, it can assume no valid
        line/column number could be provided by libSBML in that situation.

        Returns the line number.

        See also getColumn().

        """
        return _libsbml.XMLError_getLine(self)


    def getColumn(self):
        """
        getColumn(XMLError self) -> unsigned int


        Returns the column number in the XML input near where the error,
        warning or other diagnostic occurred.

        We say 'near where the problem occurred', because many factors affect
        how accurate the line/column information ultimately is.  For example,
        sometimes, the underlying XML parsers can only report such information
        for the parent XML element where an error occurs, and not for the
        specific point where the problem occurs.  In other situations, some
        parsers report invalid line and/or column numbers altogether.  If this
        occurs, libSBML sets the line and/or column number in the XMLError
        object to either 0 or the value of the maximum unsigned long integer
        representable on the platform where libSBML is running. The
        probability that a true line or column number in an SBML model would
        equal this value is vanishingly small; thus, if an application
        encounters these values in an XMLError object, it can assume no valid
        line/column number could be provided by libSBML in that situation.

        Returns the column number.

        See also getLine().

        """
        return _libsbml.XMLError_getColumn(self)


    def getSeverity(self):
        """
        getSeverity(XMLError self) -> unsigned int


        Returns the severity of this error.

        XMLError defines an enumeration of severity codes for the XML layer.
        Applications that build on XMLError by subclassing it may add their
        own severity codes with numbers higher than those in the predefined
        set of severity codes.

        Returns the severity of this XMLError.

        See also getSeverityAsString(), getCategory().

        """
        return _libsbml.XMLError_getSeverity(self)


    def getSeverityAsString(self):
        """
        getSeverityAsString(XMLError self) -> string


        Returns a string describing the severity level of this error.

        XMLError defines an enumeration of severity codes for the XML layer.
        Applications that build on XMLError by subclassing it may add their
        own severity codes with numbers higher than those in the predefined
        set of severity codes.

        Returns string representing the severity of this XMLError.

        See also getSeverity(), getCategoryAsString().

        """
        return _libsbml.XMLError_getSeverityAsString(self)


    def getCategory(self):
        """
        getCategory(XMLError self) -> unsigned int


        Returns the category of this error.

        XMLError defines an enumeration of category codes for the XML layer.
        Applications that build on XMLError by subclassing it may add their
        own categories with numbers higher than those in the predefined set of
        category codes.

        Categories can be used to partition errors into distinct groups. Among
        other things, this can be used to prevent id conflicts by uniquely
        identifying an XMLError by both id and category.

        Returns the category of this XMLError.

        See also getSeverity(), getCategoryAsString().

        """
        return _libsbml.XMLError_getCategory(self)


    def getCategoryAsString(self):
        """
        getCategoryAsString(XMLError self) -> string


        Returns a string describing the category of this error.

        XMLError defines an enumeration of category codes for the XML layer.
        Applications that build on XMLError by subclassing it may add their
        own categories with numbers higher than those in the predefined set of
        category codes.

        Categories can be used to partition errors into distinct groups. Among
        other things, this can be used to prevent id conflicts by uniquely
        identifying an XMLError by both id and category.

        Returns string representing the category of this XMLError.

        See also getCategory(), getSeverityAsString().

        """
        return _libsbml.XMLError_getCategoryAsString(self)


    def isInfo(self):
        """
        isInfo(XMLError self) -> bool


        Predicate returning 'True' or 'False' depending on whether this error
        object is for information purposes only.

        This is equivalent to obtaining the severity code from an XMLError
        object (via XMLError.getSeverity()) and then comparing it to the value
        LIBSBML_SEV_INFO from the set of predefined severity codes.

        Returns 'True' if this XMLError is for informational purposes only,
        'False' otherwise.

        See also isWarning(), isError(), isFatal().

        """
        return _libsbml.XMLError_isInfo(self)


    def isWarning(self):
        """
        isWarning(XMLError self) -> bool


        Predicate returning 'True' or 'False' depending on whether  this error
        object is a warning.

        This is equivalent to obtaining the severity code from an XMLError
        object (via XMLError.getSeverity()) and then comparing it to the value
        LIBSBML_SEV_WARNING from the set of predefined severity codes.

        Returns 'True' if this error is a warning, 'False' otherwise.

        See also isInfo(), isError(), isFatal().

        """
        return _libsbml.XMLError_isWarning(self)


    def isError(self):
        """
        isError(XMLError self) -> bool


        Predicate returning 'True' or 'False' depending on whether this error
        is a significant error.

        This is equivalent to obtaining the severity code from an XMLError
        object (via XMLError.getSeverity()) and then comparing it to the value
        LIBSBML_SEV_ERROR from the set of predefined severity codes.

        Returns 'True' if this error is an error, 'False' otherwise.

        See also isInfo(), isWarning(), isFatal().

        """
        return _libsbml.XMLError_isError(self)


    def isFatal(self):
        """
        isFatal(XMLError self) -> bool


        Predicate returning 'True' or 'False' depending on whether this error
        is a fatal run-time error.

        This is equivalent to obtaining the severity code from an XMLError
        object (via XMLError.getSeverity()) and then comparing it to the value
        LIBSBML_SEV_FATAL from the set of predefined severity codes.

        Returns 'True' if this error is a fatal error, 'False' otherwise.

        See also isInfo(), isWarning(), isError().

        """
        return _libsbml.XMLError_isFatal(self)


    def isInternal(self):
        """
        isInternal(XMLError self) -> bool


        Predicate returning 'True' or 'False' depending on whether this error
        resulted from an internal program error.

        This is equivalent to obtaining the category identifier from an
        XMLError object (via XMLError.getCategory()) and then comparing it to
        the value LIBSBML_CAT_INTERNAL from the set of predefined category
        codes.

        Returns a boolean indicating whether the error is an internal error.

        See also isSystem(), isXML().

        """
        return _libsbml.XMLError_isInternal(self)


    def isSystem(self):
        """
        isSystem(XMLError self) -> bool


        Predicate returning 'True' or 'False' depending on whether this error
        was generated by the operating system.

        This is equivalent to obtaining the category identifier from an
        XMLError object (via XMLError.getCategory()) and then comparing it to
        the value LIBSBML_CAT_SYSTEM from the set of predefined category
        codes.

        Returns boolean indicating whether the error is a system error.

        See also isInternal(), isXML().

        """
        return _libsbml.XMLError_isSystem(self)


    def isXML(self):
        """
        isXML(XMLError self) -> bool


        Predicate returning 'True' or 'False' depending on whether this error
        resulted from a problem in the XML input (e.g., an XML syntax error).

        This is equivalent to obtaining the category identifier from an
        XMLError object (via XMLError.getCategory()) and then comparing it to
        the value LIBSBML_CAT_XML from the set of predefined category codes.

        Returns a boolean indicating whether the error is an XML catetory
        error.

        See also isInternal(), isSystem().

        """
        return _libsbml.XMLError_isXML(self)


    def isValid(self):
        """
        isValid(XMLError self) -> bool


        Predicate returning 'True' or 'False' depending on whether this error
        resulted from a problem or whether it was logged as an unknown error.

        This is equivalent to obtaining the error identifier from an XMLError
        object (via XMLError.getErrorId()) and then comparing it to the value
        XMLUnknownError or UnknownError from the set of predefined error
        codes.

        Returns a boolean indicating whether the error is a valid error
        ('True)'  or whether it is unknown ('False).'

        """
        return _libsbml.XMLError_isValid(self)


    def setLine(self, line):
        """
        setLine(XMLError self, unsigned int line) -> int


        Sets the line number where this error occurred.

        Parameter 'line' is a long integer, the line number to set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        See also setColumn().

        """
        return _libsbml.XMLError_setLine(self, line)


    def setColumn(self, column):
        """
        setColumn(XMLError self, unsigned int column) -> int


        Sets the column number where this error occurred.

        Parameter 'column' is a long integer, the column number to set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        See also setLine().

        """
        return _libsbml.XMLError_setColumn(self, column)


    def getStandardMessage(code):
        """
        getStandardMessage(int const code) -> string


        Returns a copy of the message string associated with the given
        predefined XMLError code.

        Parameter 'code' is the error code whose message is sought; it must be
        a predefined value from the set of predefined error identifiers.

        """
        return _libsbml.XMLError_getStandardMessage(code)

    getStandardMessage = staticmethod(getStandardMessage)

    def getPackage(self):
        """
        getPackage(XMLError self) -> string


        Returns the SBML Level 3 package extension (if any) that logged this
        error.

        Each error logged by an libSBML extension for SBML Level 3 packages
        includes a record of the package that logged it.  The field is a
        simple text string.  If the string is empty or has the value ''core','
        then the error came from libSBML core; otherwise, the string will be
        the short-form name of the package (e.g., ''comp'' for the
        Hierarchical Model Composition package).

        Returns a string representing the name of the package that logged this
        error.  If the error did not come from a package extension, the value
        will be the empty string or ''core'.'

        """
        return _libsbml.XMLError_getPackage(self)


    def getErrorIdOffset(self):
        """
        getErrorIdOffset(XMLError self) -> unsigned int


        Returns libSBML's internal numerical offset for the error code
        associated with this error.

        In the SBML Level 3 package specifications, package validation rules
        are identified by 5-digit numbers prefixed with the nickname of the
        package itself---e.g., "comp-10101", "fbc-20301", etc.
        Historically, libSBML reported error codes as pure integers, and some
        application software systems make decisions based on the numerical
        values of the error codes.  To permit these applications to continue
        to function in this fashion, libSBML internally continues to maintain
        error identifiers as pure integers.  To handle the possibility that
        errors may come from package extensions, libSBML uses numerical
        offsets added to the internal error codes.  These offsets add two
        leading digits to the regular 5-digit error codes; for example,
        "comp" error codes are stored as 1010101, 1020102, etc.  The offset
        in this case is 1000000.  Another package will have the offset
        2000000, yet another will have 3000000, etc.

        This method returns the integer offset in this error's error code.
        Calling applications can get the 5-digit package-specific number for a
        given error code by subtracting the offset from the value reported by
        getErrorId():

           getErrorId() - getErrorIdOffset()

        When libSBML produces error messages, it combines the text string
        returned by getPackage() with the subtracted value of the error code,
        to produce a text string of the form "comp-10101".

        See also getErrorId(), getPackage().

        """
        return _libsbml.XMLError_getErrorIdOffset(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

XMLError_swigregister = _libsbml.XMLError_swigregister
XMLError_swigregister(XMLError)

def XMLError_getStandardMessage(code):
    """
    XMLError_getStandardMessage(int const code) -> string


    Returns a copy of the message string associated with the given
    predefined XMLError code.

    Parameter 'code' is the error code whose message is sought; it must be
    a predefined value from the set of predefined error identifiers.

    """
    return _libsbml.XMLError_getStandardMessage(code)

class XMLErrorLog(_object):
    """

    Log of diagnostics reported during XML processing.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    The error log is a list.  The XML layer of libSBML maintains an error
    log associated with a given XML document or data stream.  When an
    operation results in an error, or when there is something wrong with
    the XML content, the problem is reported as an XMLError object stored
    in the XMLErrorLog list.  Potential problems range from low-level
    issues (such as the inability to open a file) to XML syntax errors
    (such as mismatched tags or other problems).

    A typical approach for using this error log is to first use
    getNumErrors() to inquire how many XMLError object instances it
    contains, and then to iterate over the list of objects one at a time
    using getError(long n) .  Indexing in the list begins at 0.

    In normal circumstances, programs using libSBML will actually obtain
    an SBMLErrorLog rather than an XMLErrorLog.  The former is subclassed
    from XMLErrorLog and simply wraps commands for working with SBMLError
    objects rather than the low-level XMLError objects.  Classes such as
    SBMLDocument use the higher-level SBMLErrorLog.

    """

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, XMLErrorLog, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, XMLErrorLog, name)
    __repr__ = _swig_repr

    def getNumErrors(self):
        """
        getNumErrors(XMLErrorLog self) -> unsigned int


        Returns the number of errors that have been logged.

        To retrieve individual errors from the log, callers may use
        XMLErrorLog.getError() .

        Returns the number of errors that have been logged.

        """
        return _libsbml.XMLErrorLog_getNumErrors(self)


    def getError(self, n):
        """
        getError(XMLErrorLog self, unsigned int n) -> XMLError


        Returns the nth XMLError object in this log.

        Index 'n' is counted from 0.  Callers should first inquire about the
        number of items in the log by using the method getNumErrors().
        Attempts to use an error index number that exceeds the actual number
        of errors in the log will result in a 'None' being returned.

        Parameter 'n' is the index number of the error to retrieve (with 0
        being the first error).

        Returns the nth XMLError in this log, or 'None' if 'n' is greater than
        or equal to getNumErrors().

        See also getNumErrors().

        """
        return _libsbml.XMLErrorLog_getError(self, n)


    def clearLog(self):
        """
        clearLog(XMLErrorLog self)


        Deletes all errors from this log.

        """
        return _libsbml.XMLErrorLog_clearLog(self)


    def __init__(self, *args):
        """
        __init__(XMLErrorLog self) -> XMLErrorLog
        __init__(XMLErrorLog self, XMLErrorLog other) -> XMLErrorLog


        @internal

        """
        this = _libsbml.new_XMLErrorLog(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_XMLErrorLog
    __del__ = lambda self: None

    def add(self, *args):
        """
        add(XMLErrorLog self, XMLError error)
        add(XMLErrorLog self, std::vector< XMLError * > const & errors)
        """
        return _libsbml.XMLErrorLog_add(self, *args)


    def toString(self):
        """
        toString(XMLErrorLog self) -> string


        Writes all errors contained in this log to a string and returns it.

        This method uses printErrors() to format the diagnostic messages.
        Please consult that method for information about the organization of
        the messages in the string returned by this method.

        Returns a string containing all logged errors and warnings.

        See also printErrors().

        """
        return _libsbml.XMLErrorLog_toString(self)


    def printErrors(self, *args):
        """
        printErrors(XMLErrorLog self, ostream stream)
        printErrors(XMLErrorLog self)
        printErrors(XMLErrorLog self, ostream stream, unsigned int severity)


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            printErrors(std::ostream& stream, long severity)

        Prints the errors or warnings with given severity stored in this error
        log.

        This method prints the text to the stream given by the optional
        parameter 'stream'.  If no stream is given, the method prints the
        output to the standard error stream.

        The format of the output is:

             N error(s):
               line NNN: (id) message

        If no errors with that severity was found, then no output will be
        produced.

        Parameter 'stream' is the ostream or ostringstream object indicating
        where the output should be printed. Parameter 'severity' is the
        severity of the errors sought.

        ______________________________________________________________________
        Method variant with the following signature:

            printErrors(std::ostream& stream = std::cerr)

        Prints all the errors or warnings stored in this error log.

        This method prints the text to the stream given by the optional
        parameter 'stream'.  If no stream is given, the method prints the
        output to the standard error stream.

        The format of the output is:

             N error(s):
               line NNN: (id) message

        If no errors have occurred, i.e., getNumErrors() == 0, then no output
        will be produced. Parameter 'stream' is the ostream or ostringstream
        object indicating where the output should be printed.

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        return _libsbml.XMLErrorLog_printErrors(self, *args)


    def isSeverityOverridden(self):
        """
        isSeverityOverridden(XMLErrorLog self) -> bool


        Returns a boolean indicating whether or not the severity has been
        overridden.

        The severity override mechanism in XMLErrorLog is intended to help
        applications handle error conditions in ways that may be more
        convenient for those applications.  It is possible to use the
        mechanism to override the severity code of errors logged by libSBML,
        and even to disable error logging completely.  An override stays in
        effect until the override is changed again by the calling application.

        Returns 'True' if an error severity override has been set, 'False'
        otherwise.

        See also getSeverityOverride(), setSeverityOverride(),
        unsetSeverityOverride(), changeErrorSeverity().

        """
        return _libsbml.XMLErrorLog_isSeverityOverridden(self)


    def unsetSeverityOverride(self):
        """
        unsetSeverityOverride(XMLErrorLog self)


        Usets an existing override.

        The severity override mechanism in XMLErrorLog is intended to help
        applications handle error conditions in ways that may be more
        convenient for those applications.  It is possible to use the
        mechanism to override the severity code of errors logged by libSBML,
        and even to disable error logging completely.  An override stays in
        effect until the override is changed again by the calling application.

        See also getSeverityOverride(), setSeverityOverride(),
        isSeverityOverridden(), changeErrorSeverity().

        """
        return _libsbml.XMLErrorLog_unsetSeverityOverride(self)


    def getSeverityOverride(self):
        """
        getSeverityOverride(XMLErrorLog self) -> XMLErrorSeverityOverride_t


        Returns the current override.

        The severity override mechanism in XMLErrorLog is intended to help
        applications handle error conditions in ways that may be more
        convenient for those applications.  It is possible to use the
        mechanism to override the severity code of errors logged by libSBML,
        and even to disable error logging completely.  An override stays in
        effect until the override is changed again by the calling application.

        Returns a severity override code.  The possible values are drawn from
        the set of integer constants whose names begin with the prefix
        LIBSBML_OVERRIDE_:

        * LIBSBML_OVERRIDE_DISABLED

        * LIBSBML_OVERRIDE_DONT_LOG

        * LIBSBML_OVERRIDE_WARNING

        See also isSeverityOverridden(), setSeverityOverride(),
        unsetSeverityOverride(), changeErrorSeverity().

        """
        return _libsbml.XMLErrorLog_getSeverityOverride(self)


    def setSeverityOverride(self, severity):
        """
        setSeverityOverride(XMLErrorLog self, XMLErrorSeverityOverride_t severity)


        Set the severity override.

        The severity override mechanism in XMLErrorLog is intended to help
        applications handle error conditions in ways that may be more
        convenient for those applications.  It is possible to use the
        mechanism to override the severity code of errors logged by libSBML,
        and even to disable error logging completely.  An override stays in
        effect until the override is changed again by the calling application.

        Parameter 'severity' is an override code indicating what to do.  If
        the value is LIBSBML_OVERRIDE_DISABLED (the default setting) all
        errors logged will be given the severity specified in their usual
        definition.   If the value is LIBSBML_OVERRIDE_WARNING, then all
        errors will be logged as warnings.  If the value is
        LIBSBML_OVERRIDE_DONT_LOG, no error will be logged, regardless of
        their severity.

        See also isSeverityOverridden(), getSeverityOverride(),
        unsetSeverityOverride(), changeErrorSeverity().

        """
        return _libsbml.XMLErrorLog_setSeverityOverride(self, severity)


    def changeErrorSeverity(self, *args):
        """
        changeErrorSeverity(XMLErrorLog self, XMLErrorSeverity_t originalSeverity, XMLErrorSeverity_t targetSeverity, string package)
        changeErrorSeverity(XMLErrorLog self, XMLErrorSeverity_t originalSeverity, XMLErrorSeverity_t targetSeverity)


        Changes the severity override for errors in the log that have a given
        severity.

        This method searches through the list of errors in the log, comparing
        each one's severity to the value of 'originalSeverity'.  For each
        error encountered with that severity logged by the named 'package',
        the severity of the error is reset to 'targetSeverity'.

        The severity override mechanism in XMLErrorLog is intended to help
        applications handle error conditions in ways that may be more
        convenient for those applications.  It is possible to use the
        mechanism to override the severity code of errors logged by libSBML,
        and even to disable error logging completely.  An override stays in
        effect until the override is changed again by the calling application.

        Parameter 'originalSeverity' is the severity code to match.

        Parameter 'targetSeverity' is the severity code to use as the new
        severity.

        Parameter 'package' is a string, the name of an SBML Level 3 package
        extension to use to narrow the search for errors.  A value of ''all''
        signifies to match against errors logged from any package; a value of
        a package nickname such as ''comp'' signifies to limit consideration
        to errors from just that package.  If no value is provided, ''all'' is
        the default.

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        See also isSeverityOverridden(), getSeverityOverride(),
        setSeverityOverride(), unsetSeverityOverride().

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        return _libsbml.XMLErrorLog_changeErrorSeverity(self, *args)


    def contains(self, errorId):
        """
        contains(XMLErrorLog self, unsigned int const errorId) -> bool


        Returns 'True' if XMLErrorLog contains an errorId

        Parameter 'errorId' is the error identifier of the error to be found.

        """
        return _libsbml.XMLErrorLog_contains(self, errorId)


    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

XMLErrorLog_swigregister = _libsbml.XMLErrorLog_swigregister
XMLErrorLog_swigregister(XMLErrorLog)

class SBMLErrorLog(XMLErrorLog):
    """

    Log of diagnostics reported during processing.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    The error log is a list.  Each SBMLDocument maintains its own
    SBMLErrorLog.  When a libSBML operation on SBML content results in an
    error, or when there is something worth noting about the SBML content,
    the issue is reported as an SBMLError object stored in the
    SBMLErrorLog list.

    SBMLErrorLog is derived from XMLErrorLog, an object class that serves
    exactly the same purpose but for the XML parsing layer.  XMLErrorLog
    provides crucial methods such as getNumErrors() for determining how
    many SBMLError or XMLError objects are in the log. SBMLErrorLog
    inherits these methods.

    The general approach to working with SBMLErrorLog in user programs
    involves first obtaining a pointer to a log from a libSBML object such
    as SBMLDocument.  Callers should then use getNumErrors()  to inquire
    how many objects there are in the list.  (The answer may be 0.)  If
    there is at least one SBMLError object in the SBMLErrorLog instance,
    callers can then iterate over the list using
    SBMLErrorLog.getError()@if clike @endif, using methods provided by the
    SBMLError class to find out the error code and associated information
    such as the error severity, the message, and the line number in the
    input.

    If you wish to simply print the error strings for a human to read, an
    easier and more direct way might be to use SBMLDocument.printErrors().

    See also SBMLError, XMLErrorLog, XMLError.

    """

    __swig_setmethods__ = {}
    for _s in [XMLErrorLog]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLErrorLog, name, value)
    __swig_getmethods__ = {}
    for _s in [XMLErrorLog]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SBMLErrorLog, name)
    __repr__ = _swig_repr

    def getError(self, n):
        """
        getError(SBMLErrorLog self, unsigned int n) -> SBMLError


        Returns the nth SBMLError object in this log.

        Index 'n' is counted from 0.  Callers should first inquire about the
        number of items in the log by using the getNumErrors() method.
        Attempts to use an error index number that exceeds the actual number
        of errors in the log will result in a 'None' being returned.

        Parameter 'n' is the index number of the error to retrieve (with 0
        being the first error).

        Returns the nth SBMLError in this log, or 'None' if 'n' is greater
        than or equal to getNumErrors().

        See also getNumErrors().

        """
        return _libsbml.SBMLErrorLog_getError(self, n)


    def getErrorWithSeverity(self, n, severity):
        """
        getErrorWithSeverity(SBMLErrorLog self, unsigned int n, unsigned int severity) -> SBMLError


        Returns the nth SBMLError object with given severity in this log.

        Index 'n' is counted from 0.  Callers should first inquire about the
        number of items in the log by using the getNumFailsWithSeverity()
        method. Attempts to use an error index number that exceeds the actual
        number of errors in the log will result in a 'None' being returned.

        Parameter 'n' is the index number of the error to retrieve (with 0
        being the first error). Parameter 'severity' is the severity of the
        error to retrieve.

        Returns the nth SBMLError in this log, or 'None' if 'n' is greater
        than or equal to getNumFailsWithSeverity().

        See also getNumFailsWithSeverity().

        """
        return _libsbml.SBMLErrorLog_getErrorWithSeverity(self, n, severity)


    def getNumFailsWithSeverity(self, *args):
        """
        getNumFailsWithSeverity(SBMLErrorLog self, unsigned int severity) -> unsigned int
        getNumFailsWithSeverity(SBMLErrorLog self, unsigned int severity) -> unsigned int


        Returns the number of errors that have been logged with the given
        severity code.

        LibSBML associates severity levels with every SBMLError object to
        provide an indication of how serious the problem is.  Severities range
        from informational diagnostics to fatal (irrecoverable) errors.  Given
        an SBMLError object instance, a caller can interrogate it for its
        severity level using methods such as SBMLError.getSeverity(),
        SBMLError.isFatal(), and so on.  The present method encapsulates
        iteration and interrogation of all objects in an SBMLErrorLog, making
        it easy to check for the presence of error objects with specific
        severity levels.

        Parameter 'severity' is a value from the set of LIBSBML_SEV_ constants
        defined by the interface class libsbml.

        Returns a count of the number of errors with the given severity code.

        See also getNumErrors().

        """
        return _libsbml.SBMLErrorLog_getNumFailsWithSeverity(self, *args)


    def __init__(self, *args):
        """
        __init__(SBMLErrorLog self) -> SBMLErrorLog
        __init__(SBMLErrorLog self, SBMLErrorLog orig) -> SBMLErrorLog


        @internal

        """
        this = _libsbml.new_SBMLErrorLog(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_SBMLErrorLog
    __del__ = lambda self: None

    def logError(self, *args):
        """
        logError(SBMLErrorLog self, unsigned int const errorId=0, unsigned int const level, unsigned int const version, string details, unsigned int const line=0, unsigned int const column=0, unsigned int const severity=LIBSBML_SEV_ERROR, unsigned int const category=LIBSBML_CAT_SBML)
        logError(SBMLErrorLog self, unsigned int const errorId=0, unsigned int const level, unsigned int const version, string details, unsigned int const line=0, unsigned int const column=0, unsigned int const severity=LIBSBML_SEV_ERROR)
        logError(SBMLErrorLog self, unsigned int const errorId=0, unsigned int const level, unsigned int const version, string details, unsigned int const line=0, unsigned int const column=0)
        logError(SBMLErrorLog self, unsigned int const errorId=0, unsigned int const level, unsigned int const version, string details, unsigned int const line=0)
        logError(SBMLErrorLog self, unsigned int const errorId=0, unsigned int const level, unsigned int const version, string details)
        logError(SBMLErrorLog self, unsigned int const errorId=0, unsigned int const level, unsigned int const version)
        logError(SBMLErrorLog self, unsigned int const errorId=0, unsigned int const level)
        logError(SBMLErrorLog self, unsigned int const errorId=0)
        logError(SBMLErrorLog self)


        Internal implementation method.

        """
        return _libsbml.SBMLErrorLog_logError(self, *args)


    def logPackageError(self, *args):
        """
        logPackageError(SBMLErrorLog self, string package, unsigned int const errorId=0, unsigned int const pkgVersion=1, unsigned int const level, unsigned int const version, string details, unsigned int const line=0, unsigned int const column=0, unsigned int const severity=LIBSBML_SEV_ERROR, unsigned int const category=LIBSBML_CAT_SBML)
        logPackageError(SBMLErrorLog self, string package, unsigned int const errorId=0, unsigned int const pkgVersion=1, unsigned int const level, unsigned int const version, string details, unsigned int const line=0, unsigned int const column=0, unsigned int const severity=LIBSBML_SEV_ERROR)
        logPackageError(SBMLErrorLog self, string package, unsigned int const errorId=0, unsigned int const pkgVersion=1, unsigned int const level, unsigned int const version, string details, unsigned int const line=0, unsigned int const column=0)
        logPackageError(SBMLErrorLog self, string package, unsigned int const errorId=0, unsigned int const pkgVersion=1, unsigned int const level, unsigned int const version, string details, unsigned int const line=0)
        logPackageError(SBMLErrorLog self, string package, unsigned int const errorId=0, unsigned int const pkgVersion=1, unsigned int const level, unsigned int const version, string details)
        logPackageError(SBMLErrorLog self, string package, unsigned int const errorId=0, unsigned int const pkgVersion=1, unsigned int const level, unsigned int const version)
        logPackageError(SBMLErrorLog self, string package, unsigned int const errorId=0, unsigned int const pkgVersion=1, unsigned int const level)
        logPackageError(SBMLErrorLog self, string package, unsigned int const errorId=0, unsigned int const pkgVersion=1)
        logPackageError(SBMLErrorLog self, string package, unsigned int const errorId=0)
        logPackageError(SBMLErrorLog self, string package)
        logPackageError(SBMLErrorLog self)


        Internal implementation method.

        """
        return _libsbml.SBMLErrorLog_logPackageError(self, *args)


    def add(self, error):
        """add(SBMLErrorLog self, SBMLError error)"""
        return _libsbml.SBMLErrorLog_add(self, error)


    def remove(self, errorId):
        """
        remove(SBMLErrorLog self, unsigned int const errorId)


        Removes an error having errorId from the SBMLError list.

        Only the first item will be removed if there are multiple errors with
        the given errorId.

        Parameter 'errorId' is the error identifier of the error to be
        removed.

        """
        return _libsbml.SBMLErrorLog_remove(self, errorId)


    def removeAll(self, errorId):
        """
        removeAll(SBMLErrorLog self, unsigned int const errorId)


        Removes all errors having errorId from the SBMLError list.

        Parameter 'errorId' is the error identifier of the error to be
        removed.

        """
        return _libsbml.SBMLErrorLog_removeAll(self, errorId)


    def contains(self, errorId):
        """
        contains(SBMLErrorLog self, unsigned int const errorId) -> bool


        Returns 'True' if SBMLErrorLog contains an errorId

        Parameter 'errorId' is the error identifier of the error to be found.

        """
        return _libsbml.SBMLErrorLog_contains(self, errorId)

SBMLErrorLog_swigregister = _libsbml.SBMLErrorLog_swigregister
SBMLErrorLog_swigregister(SBMLErrorLog)

UnknownError = _libsbml.UnknownError
NotUTF8 = _libsbml.NotUTF8
UnrecognizedElement = _libsbml.UnrecognizedElement
NotSchemaConformant = _libsbml.NotSchemaConformant
L3NotSchemaConformant = _libsbml.L3NotSchemaConformant
InvalidMathElement = _libsbml.InvalidMathElement
DisallowedMathMLSymbol = _libsbml.DisallowedMathMLSymbol
DisallowedMathMLEncodingUse = _libsbml.DisallowedMathMLEncodingUse
DisallowedDefinitionURLUse = _libsbml.DisallowedDefinitionURLUse
BadCsymbolDefinitionURLValue = _libsbml.BadCsymbolDefinitionURLValue
DisallowedMathTypeAttributeUse = _libsbml.DisallowedMathTypeAttributeUse
DisallowedMathTypeAttributeValue = _libsbml.DisallowedMathTypeAttributeValue
LambdaOnlyAllowedInFunctionDef = _libsbml.LambdaOnlyAllowedInFunctionDef
BooleanOpsNeedBooleanArgs = _libsbml.BooleanOpsNeedBooleanArgs
NumericOpsNeedNumericArgs = _libsbml.NumericOpsNeedNumericArgs
ArgsToEqNeedSameType = _libsbml.ArgsToEqNeedSameType
PiecewiseNeedsConsistentTypes = _libsbml.PiecewiseNeedsConsistentTypes
PieceNeedsBoolean = _libsbml.PieceNeedsBoolean
ApplyCiMustBeUserFunction = _libsbml.ApplyCiMustBeUserFunction
ApplyCiMustBeModelComponent = _libsbml.ApplyCiMustBeModelComponent
KineticLawParametersAreLocalOnly = _libsbml.KineticLawParametersAreLocalOnly
MathResultMustBeNumeric = _libsbml.MathResultMustBeNumeric
OpsNeedCorrectNumberOfArgs = _libsbml.OpsNeedCorrectNumberOfArgs
InvalidNoArgsPassedToFunctionDef = _libsbml.InvalidNoArgsPassedToFunctionDef
DisallowedMathUnitsUse = _libsbml.DisallowedMathUnitsUse
InvalidUnitsValue = _libsbml.InvalidUnitsValue
CiCannotReference0DCompartment = _libsbml.CiCannotReference0DCompartment
RateOfTargetMustBeCi = _libsbml.RateOfTargetMustBeCi
RateOfTargetCannotBeAssigned = _libsbml.RateOfTargetCannotBeAssigned
RateOfSpeciesTargetCompartmentNot = _libsbml.RateOfSpeciesTargetCompartmentNot
DuplicateComponentId = _libsbml.DuplicateComponentId
DuplicateUnitDefinitionId = _libsbml.DuplicateUnitDefinitionId
DuplicateLocalParameterId = _libsbml.DuplicateLocalParameterId
MultipleAssignmentOrRateRules = _libsbml.MultipleAssignmentOrRateRules
MultipleEventAssignmentsForId = _libsbml.MultipleEventAssignmentsForId
EventAndAssignmentRuleForId = _libsbml.EventAndAssignmentRuleForId
DuplicateMetaId = _libsbml.DuplicateMetaId
InvalidSBOTermSyntax = _libsbml.InvalidSBOTermSyntax
InvalidMetaidSyntax = _libsbml.InvalidMetaidSyntax
InvalidIdSyntax = _libsbml.InvalidIdSyntax
InvalidUnitIdSyntax = _libsbml.InvalidUnitIdSyntax
InvalidNameSyntax = _libsbml.InvalidNameSyntax
DanglingUnitReference = _libsbml.DanglingUnitReference
MissingAnnotationNamespace = _libsbml.MissingAnnotationNamespace
DuplicateAnnotationNamespaces = _libsbml.DuplicateAnnotationNamespaces
SBMLNamespaceInAnnotation = _libsbml.SBMLNamespaceInAnnotation
MultipleAnnotations = _libsbml.MultipleAnnotations
InconsistentArgUnits = _libsbml.InconsistentArgUnits
InconsistentKineticLawUnitsL3 = _libsbml.InconsistentKineticLawUnitsL3
AssignRuleCompartmentMismatch = _libsbml.AssignRuleCompartmentMismatch
AssignRuleSpeciesMismatch = _libsbml.AssignRuleSpeciesMismatch
AssignRuleParameterMismatch = _libsbml.AssignRuleParameterMismatch
AssignRuleStoichiometryMismatch = _libsbml.AssignRuleStoichiometryMismatch
InitAssignCompartmenMismatch = _libsbml.InitAssignCompartmenMismatch
InitAssignSpeciesMismatch = _libsbml.InitAssignSpeciesMismatch
InitAssignParameterMismatch = _libsbml.InitAssignParameterMismatch
InitAssignStoichiometryMismatch = _libsbml.InitAssignStoichiometryMismatch
RateRuleCompartmentMismatch = _libsbml.RateRuleCompartmentMismatch
RateRuleSpeciesMismatch = _libsbml.RateRuleSpeciesMismatch
RateRuleParameterMismatch = _libsbml.RateRuleParameterMismatch
RateRuleStoichiometryMismatch = _libsbml.RateRuleStoichiometryMismatch
KineticLawNotSubstancePerTime = _libsbml.KineticLawNotSubstancePerTime
SpeciesInvalidExtentUnits = _libsbml.SpeciesInvalidExtentUnits
DelayUnitsNotTime = _libsbml.DelayUnitsNotTime
EventAssignCompartmentMismatch = _libsbml.EventAssignCompartmentMismatch
EventAssignSpeciesMismatch = _libsbml.EventAssignSpeciesMismatch
EventAssignParameterMismatch = _libsbml.EventAssignParameterMismatch
EventAssignStoichiometryMismatch = _libsbml.EventAssignStoichiometryMismatch
PriorityUnitsNotDimensionless = _libsbml.PriorityUnitsNotDimensionless
UpperUnitBound = _libsbml.UpperUnitBound
OverdeterminedSystem = _libsbml.OverdeterminedSystem
InvalidModelSBOTerm = _libsbml.InvalidModelSBOTerm
InvalidFunctionDefSBOTerm = _libsbml.InvalidFunctionDefSBOTerm
InvalidParameterSBOTerm = _libsbml.InvalidParameterSBOTerm
InvalidInitAssignSBOTerm = _libsbml.InvalidInitAssignSBOTerm
InvalidRuleSBOTerm = _libsbml.InvalidRuleSBOTerm
InvalidConstraintSBOTerm = _libsbml.InvalidConstraintSBOTerm
InvalidReactionSBOTerm = _libsbml.InvalidReactionSBOTerm
InvalidSpeciesReferenceSBOTerm = _libsbml.InvalidSpeciesReferenceSBOTerm
InvalidKineticLawSBOTerm = _libsbml.InvalidKineticLawSBOTerm
InvalidEventSBOTerm = _libsbml.InvalidEventSBOTerm
InvalidEventAssignmentSBOTerm = _libsbml.InvalidEventAssignmentSBOTerm
InvalidCompartmentSBOTerm = _libsbml.InvalidCompartmentSBOTerm
InvalidSpeciesSBOTerm = _libsbml.InvalidSpeciesSBOTerm
InvalidCompartmentTypeSBOTerm = _libsbml.InvalidCompartmentTypeSBOTerm
InvalidSpeciesTypeSBOTerm = _libsbml.InvalidSpeciesTypeSBOTerm
InvalidTriggerSBOTerm = _libsbml.InvalidTriggerSBOTerm
InvalidDelaySBOTerm = _libsbml.InvalidDelaySBOTerm
InvalidLocalParameterSBOTerm = _libsbml.InvalidLocalParameterSBOTerm
InvalidSBMLElementSBOTerm = _libsbml.InvalidSBMLElementSBOTerm
NotesNotInXHTMLNamespace = _libsbml.NotesNotInXHTMLNamespace
NotesContainsXMLDecl = _libsbml.NotesContainsXMLDecl
NotesContainsDOCTYPE = _libsbml.NotesContainsDOCTYPE
InvalidNotesContent = _libsbml.InvalidNotesContent
OnlyOneNotesElementAllowed = _libsbml.OnlyOneNotesElementAllowed
InvalidNamespaceOnSBML = _libsbml.InvalidNamespaceOnSBML
MissingOrInconsistentLevel = _libsbml.MissingOrInconsistentLevel
MissingOrInconsistentVersion = _libsbml.MissingOrInconsistentVersion
PackageNSMustMatch = _libsbml.PackageNSMustMatch
LevelPositiveInteger = _libsbml.LevelPositiveInteger
VersionPositiveInteger = _libsbml.VersionPositiveInteger
AllowedAttributesOnSBML = _libsbml.AllowedAttributesOnSBML
L3PackageOnLowerSBML = _libsbml.L3PackageOnLowerSBML
MissingModel = _libsbml.MissingModel
IncorrectOrderInModel = _libsbml.IncorrectOrderInModel
EmptyListElement = _libsbml.EmptyListElement
NeedCompartmentIfHaveSpecies = _libsbml.NeedCompartmentIfHaveSpecies
OneOfEachListOf = _libsbml.OneOfEachListOf
OnlyFuncDefsInListOfFuncDefs = _libsbml.OnlyFuncDefsInListOfFuncDefs
OnlyUnitDefsInListOfUnitDefs = _libsbml.OnlyUnitDefsInListOfUnitDefs
OnlyCompartmentsInListOfCompartments = _libsbml.OnlyCompartmentsInListOfCompartments
OnlySpeciesInListOfSpecies = _libsbml.OnlySpeciesInListOfSpecies
OnlyParametersInListOfParameters = _libsbml.OnlyParametersInListOfParameters
OnlyInitAssignsInListOfInitAssigns = _libsbml.OnlyInitAssignsInListOfInitAssigns
OnlyRulesInListOfRules = _libsbml.OnlyRulesInListOfRules
OnlyConstraintsInListOfConstraints = _libsbml.OnlyConstraintsInListOfConstraints
OnlyReactionsInListOfReactions = _libsbml.OnlyReactionsInListOfReactions
OnlyEventsInListOfEvents = _libsbml.OnlyEventsInListOfEvents
L3ConversionFactorOnModel = _libsbml.L3ConversionFactorOnModel
L3TimeUnitsOnModel = _libsbml.L3TimeUnitsOnModel
L3VolumeUnitsOnModel = _libsbml.L3VolumeUnitsOnModel
L3AreaUnitsOnModel = _libsbml.L3AreaUnitsOnModel
L3LengthUnitsOnModel = _libsbml.L3LengthUnitsOnModel
L3ExtentUnitsOnModel = _libsbml.L3ExtentUnitsOnModel
AllowedAttributesOnModel = _libsbml.AllowedAttributesOnModel
AllowedAttributesOnListOfFuncs = _libsbml.AllowedAttributesOnListOfFuncs
AllowedAttributesOnListOfUnitDefs = _libsbml.AllowedAttributesOnListOfUnitDefs
AllowedAttributesOnListOfComps = _libsbml.AllowedAttributesOnListOfComps
AllowedAttributesOnListOfSpecies = _libsbml.AllowedAttributesOnListOfSpecies
AllowedAttributesOnListOfParams = _libsbml.AllowedAttributesOnListOfParams
AllowedAttributesOnListOfInitAssign = _libsbml.AllowedAttributesOnListOfInitAssign
AllowedAttributesOnListOfRules = _libsbml.AllowedAttributesOnListOfRules
AllowedAttributesOnListOfConstraints = _libsbml.AllowedAttributesOnListOfConstraints
AllowedAttributesOnListOfReactions = _libsbml.AllowedAttributesOnListOfReactions
AllowedAttributesOnListOfEvents = _libsbml.AllowedAttributesOnListOfEvents
L3V2SubstanceUnitsOnModel = _libsbml.L3V2SubstanceUnitsOnModel
FunctionDefMathNotLambda = _libsbml.FunctionDefMathNotLambda
InvalidApplyCiInLambda = _libsbml.InvalidApplyCiInLambda
RecursiveFunctionDefinition = _libsbml.RecursiveFunctionDefinition
InvalidCiInLambda = _libsbml.InvalidCiInLambda
InvalidFunctionDefReturnType = _libsbml.InvalidFunctionDefReturnType
OneMathElementPerFunc = _libsbml.OneMathElementPerFunc
AllowedAttributesOnFunc = _libsbml.AllowedAttributesOnFunc
OnlyCiInsideBVar = _libsbml.OnlyCiInsideBVar
InvalidUnitDefId = _libsbml.InvalidUnitDefId
InvalidSubstanceRedefinition = _libsbml.InvalidSubstanceRedefinition
InvalidLengthRedefinition = _libsbml.InvalidLengthRedefinition
InvalidAreaRedefinition = _libsbml.InvalidAreaRedefinition
InvalidTimeRedefinition = _libsbml.InvalidTimeRedefinition
InvalidVolumeRedefinition = _libsbml.InvalidVolumeRedefinition
VolumeLitreDefExponentNotOne = _libsbml.VolumeLitreDefExponentNotOne
VolumeMetreDefExponentNot3 = _libsbml.VolumeMetreDefExponentNot3
EmptyListOfUnits = _libsbml.EmptyListOfUnits
InvalidUnitKind = _libsbml.InvalidUnitKind
OffsetNoLongerValid = _libsbml.OffsetNoLongerValid
CelsiusNoLongerValid = _libsbml.CelsiusNoLongerValid
EmptyUnitListElement = _libsbml.EmptyUnitListElement
OneListOfUnitsPerUnitDef = _libsbml.OneListOfUnitsPerUnitDef
OnlyUnitsInListOfUnits = _libsbml.OnlyUnitsInListOfUnits
AllowedAttributesOnUnitDefinition = _libsbml.AllowedAttributesOnUnitDefinition
AllowedAttributesOnListOfUnits = _libsbml.AllowedAttributesOnListOfUnits
AllowedAttributesOnUnit = _libsbml.AllowedAttributesOnUnit
ZeroDimensionalCompartmentSize = _libsbml.ZeroDimensionalCompartmentSize
ZeroDimensionalCompartmentUnits = _libsbml.ZeroDimensionalCompartmentUnits
ZeroDimensionalCompartmentConst = _libsbml.ZeroDimensionalCompartmentConst
UndefinedOutsideCompartment = _libsbml.UndefinedOutsideCompartment
RecursiveCompartmentContainment = _libsbml.RecursiveCompartmentContainment
ZeroDCompartmentContainment = _libsbml.ZeroDCompartmentContainment
Invalid1DCompartmentUnits = _libsbml.Invalid1DCompartmentUnits
Invalid2DCompartmentUnits = _libsbml.Invalid2DCompartmentUnits
Invalid3DCompartmentUnits = _libsbml.Invalid3DCompartmentUnits
InvalidCompartmentTypeRef = _libsbml.InvalidCompartmentTypeRef
OneDimensionalCompartmentUnits = _libsbml.OneDimensionalCompartmentUnits
TwoDimensionalCompartmentUnits = _libsbml.TwoDimensionalCompartmentUnits
ThreeDimensionalCompartmentUnits = _libsbml.ThreeDimensionalCompartmentUnits
AllowedAttributesOnCompartment = _libsbml.AllowedAttributesOnCompartment
NoUnitsOnCompartment = _libsbml.NoUnitsOnCompartment
InvalidSpeciesCompartmentRef = _libsbml.InvalidSpeciesCompartmentRef
HasOnlySubsNoSpatialUnits = _libsbml.HasOnlySubsNoSpatialUnits
NoSpatialUnitsInZeroD = _libsbml.NoSpatialUnitsInZeroD
NoConcentrationInZeroD = _libsbml.NoConcentrationInZeroD
SpatialUnitsInOneD = _libsbml.SpatialUnitsInOneD
SpatialUnitsInTwoD = _libsbml.SpatialUnitsInTwoD
SpatialUnitsInThreeD = _libsbml.SpatialUnitsInThreeD
InvalidSpeciesSusbstanceUnits = _libsbml.InvalidSpeciesSusbstanceUnits
BothAmountAndConcentrationSet = _libsbml.BothAmountAndConcentrationSet
NonBoundarySpeciesAssignedAndUsed = _libsbml.NonBoundarySpeciesAssignedAndUsed
NonConstantSpeciesUsed = _libsbml.NonConstantSpeciesUsed
InvalidSpeciesTypeRef = _libsbml.InvalidSpeciesTypeRef
MultSpeciesSameTypeInCompartment = _libsbml.MultSpeciesSameTypeInCompartment
MissingSpeciesCompartment = _libsbml.MissingSpeciesCompartment
SpatialSizeUnitsRemoved = _libsbml.SpatialSizeUnitsRemoved
SubstanceUnitsOnSpecies = _libsbml.SubstanceUnitsOnSpecies
ConversionFactorOnSpecies = _libsbml.ConversionFactorOnSpecies
AllowedAttributesOnSpecies = _libsbml.AllowedAttributesOnSpecies
InvalidParameterUnits = _libsbml.InvalidParameterUnits
ParameterUnits = _libsbml.ParameterUnits
ConversionFactorMustConstant = _libsbml.ConversionFactorMustConstant
AllowedAttributesOnParameter = _libsbml.AllowedAttributesOnParameter
InvalidInitAssignSymbol = _libsbml.InvalidInitAssignSymbol
MultipleInitAssignments = _libsbml.MultipleInitAssignments
InitAssignmentAndRuleForSameId = _libsbml.InitAssignmentAndRuleForSameId
OneMathElementPerInitialAssign = _libsbml.OneMathElementPerInitialAssign
AllowedAttributesOnInitialAssign = _libsbml.AllowedAttributesOnInitialAssign
InitAssignmentCannotRef0DComp = _libsbml.InitAssignmentCannotRef0DComp
InvalidAssignRuleVariable = _libsbml.InvalidAssignRuleVariable
InvalidRateRuleVariable = _libsbml.InvalidRateRuleVariable
AssignmentToConstantEntity = _libsbml.AssignmentToConstantEntity
RateRuleForConstantEntity = _libsbml.RateRuleForConstantEntity
RepeatedRule10304 = _libsbml.RepeatedRule10304
CircularRuleDependency = _libsbml.CircularRuleDependency
OneMathElementPerRule = _libsbml.OneMathElementPerRule
AllowedAttributesOnAssignRule = _libsbml.AllowedAttributesOnAssignRule
AllowedAttributesOnRateRule = _libsbml.AllowedAttributesOnRateRule
AllowedAttributesOnAlgRule = _libsbml.AllowedAttributesOnAlgRule
RuleCannotRef0DComp = _libsbml.RuleCannotRef0DComp
CircularDependencyRateOf = _libsbml.CircularDependencyRateOf
ConstraintMathNotBoolean = _libsbml.ConstraintMathNotBoolean
IncorrectOrderInConstraint = _libsbml.IncorrectOrderInConstraint
ConstraintNotInXHTMLNamespace = _libsbml.ConstraintNotInXHTMLNamespace
ConstraintContainsXMLDecl = _libsbml.ConstraintContainsXMLDecl
ConstraintContainsDOCTYPE = _libsbml.ConstraintContainsDOCTYPE
InvalidConstraintContent = _libsbml.InvalidConstraintContent
OneMathElementPerConstraint = _libsbml.OneMathElementPerConstraint
OneMessageElementPerConstraint = _libsbml.OneMessageElementPerConstraint
AllowedAttributesOnConstraint = _libsbml.AllowedAttributesOnConstraint
NoReactantsOrProducts = _libsbml.NoReactantsOrProducts
IncorrectOrderInReaction = _libsbml.IncorrectOrderInReaction
EmptyListInReaction = _libsbml.EmptyListInReaction
InvalidReactantsProductsList = _libsbml.InvalidReactantsProductsList
InvalidModifiersList = _libsbml.InvalidModifiersList
OneSubElementPerReaction = _libsbml.OneSubElementPerReaction
CompartmentOnReaction = _libsbml.CompartmentOnReaction
AllowedAttributesOnReaction = _libsbml.AllowedAttributesOnReaction
InvalidSpeciesReference = _libsbml.InvalidSpeciesReference
RepeatedRule20611 = _libsbml.RepeatedRule20611
BothStoichiometryAndMath = _libsbml.BothStoichiometryAndMath
AllowedAttributesOnSpeciesReference = _libsbml.AllowedAttributesOnSpeciesReference
AllowedAttributesOnModifier = _libsbml.AllowedAttributesOnModifier
UndeclaredSpeciesRef = _libsbml.UndeclaredSpeciesRef
IncorrectOrderInKineticLaw = _libsbml.IncorrectOrderInKineticLaw
EmptyListInKineticLaw = _libsbml.EmptyListInKineticLaw
NonConstantLocalParameter = _libsbml.NonConstantLocalParameter
SubsUnitsNoLongerValid = _libsbml.SubsUnitsNoLongerValid
TimeUnitsNoLongerValid = _libsbml.TimeUnitsNoLongerValid
OneListOfPerKineticLaw = _libsbml.OneListOfPerKineticLaw
OnlyLocalParamsInListOfLocalParams = _libsbml.OnlyLocalParamsInListOfLocalParams
AllowedAttributesOnListOfLocalParam = _libsbml.AllowedAttributesOnListOfLocalParam
OneMathPerKineticLaw = _libsbml.OneMathPerKineticLaw
UndeclaredSpeciesInStoichMath = _libsbml.UndeclaredSpeciesInStoichMath
AllowedAttributesOnKineticLaw = _libsbml.AllowedAttributesOnKineticLaw
AllowedAttributesOnListOfSpeciesRef = _libsbml.AllowedAttributesOnListOfSpeciesRef
AllowedAttributesOnListOfMods = _libsbml.AllowedAttributesOnListOfMods
L3V2FastDeprecated = _libsbml.L3V2FastDeprecated
AllowedAttributesOnLocalParameter = _libsbml.AllowedAttributesOnLocalParameter
LocalParameterShadowsSpecies = _libsbml.LocalParameterShadowsSpecies
MissingTriggerInEvent = _libsbml.MissingTriggerInEvent
TriggerMathNotBoolean = _libsbml.TriggerMathNotBoolean
MissingEventAssignment = _libsbml.MissingEventAssignment
TimeUnitsEvent = _libsbml.TimeUnitsEvent
IncorrectOrderInEvent = _libsbml.IncorrectOrderInEvent
ValuesFromTriggerTimeNeedDelay = _libsbml.ValuesFromTriggerTimeNeedDelay
DelayNeedsValuesFromTriggerTime = _libsbml.DelayNeedsValuesFromTriggerTime
OneMathPerTrigger = _libsbml.OneMathPerTrigger
OneMathPerDelay = _libsbml.OneMathPerDelay
InvalidEventAssignmentVariable = _libsbml.InvalidEventAssignmentVariable
EventAssignmentForConstantEntity = _libsbml.EventAssignmentForConstantEntity
OneMathPerEventAssignment = _libsbml.OneMathPerEventAssignment
AllowedAttributesOnEventAssignment = _libsbml.AllowedAttributesOnEventAssignment
OnlyOneDelayPerEvent = _libsbml.OnlyOneDelayPerEvent
OneListOfEventAssignmentsPerEvent = _libsbml.OneListOfEventAssignmentsPerEvent
OnlyEventAssignInListOfEventAssign = _libsbml.OnlyEventAssignInListOfEventAssign
AllowedAttributesOnListOfEventAssign = _libsbml.AllowedAttributesOnListOfEventAssign
AllowedAttributesOnEvent = _libsbml.AllowedAttributesOnEvent
AllowedAttributesOnTrigger = _libsbml.AllowedAttributesOnTrigger
AllowedAttributesOnDelay = _libsbml.AllowedAttributesOnDelay
PersistentNotBoolean = _libsbml.PersistentNotBoolean
InitialValueNotBoolean = _libsbml.InitialValueNotBoolean
OnlyOnePriorityPerEvent = _libsbml.OnlyOnePriorityPerEvent
OneMathPerPriority = _libsbml.OneMathPerPriority
AllowedAttributesOnPriority = _libsbml.AllowedAttributesOnPriority
GeneralWarningNotSpecified = _libsbml.GeneralWarningNotSpecified
CompartmentShouldHaveSize = _libsbml.CompartmentShouldHaveSize
SpeciesShouldHaveValue = _libsbml.SpeciesShouldHaveValue
ParameterShouldHaveUnits = _libsbml.ParameterShouldHaveUnits
ParameterShouldHaveValue = _libsbml.ParameterShouldHaveValue
LocalParameterShadowsId = _libsbml.LocalParameterShadowsId
LibSBMLAdditionalCodesLowerBound = _libsbml.LibSBMLAdditionalCodesLowerBound
CannotConvertToL1V1 = _libsbml.CannotConvertToL1V1
NoEventsInL1 = _libsbml.NoEventsInL1
NoFunctionDefinitionsInL1 = _libsbml.NoFunctionDefinitionsInL1
NoConstraintsInL1 = _libsbml.NoConstraintsInL1
NoInitialAssignmentsInL1 = _libsbml.NoInitialAssignmentsInL1
NoSpeciesTypesInL1 = _libsbml.NoSpeciesTypesInL1
NoCompartmentTypeInL1 = _libsbml.NoCompartmentTypeInL1
NoNon3DCompartmentsInL1 = _libsbml.NoNon3DCompartmentsInL1
NoFancyStoichiometryMathInL1 = _libsbml.NoFancyStoichiometryMathInL1
NoNonIntegerStoichiometryInL1 = _libsbml.NoNonIntegerStoichiometryInL1
NoUnitMultipliersOrOffsetsInL1 = _libsbml.NoUnitMultipliersOrOffsetsInL1
SpeciesCompartmentRequiredInL1 = _libsbml.SpeciesCompartmentRequiredInL1
NoSpeciesSpatialSizeUnitsInL1 = _libsbml.NoSpeciesSpatialSizeUnitsInL1
NoSBOTermsInL1 = _libsbml.NoSBOTermsInL1
StrictUnitsRequiredInL1 = _libsbml.StrictUnitsRequiredInL1
ConversionFactorNotInL1 = _libsbml.ConversionFactorNotInL1
CompartmentNotOnL1Reaction = _libsbml.CompartmentNotOnL1Reaction
ExtentUnitsNotSubstance = _libsbml.ExtentUnitsNotSubstance
GlobalUnitsNotDeclared = _libsbml.GlobalUnitsNotDeclared
HasOnlySubstanceUnitsNotinL1 = _libsbml.HasOnlySubstanceUnitsNotinL1
AvogadroNotSupported = _libsbml.AvogadroNotSupported
NoConstraintsInL2v1 = _libsbml.NoConstraintsInL2v1
NoInitialAssignmentsInL2v1 = _libsbml.NoInitialAssignmentsInL2v1
NoSpeciesTypeInL2v1 = _libsbml.NoSpeciesTypeInL2v1
NoCompartmentTypeInL2v1 = _libsbml.NoCompartmentTypeInL2v1
NoSBOTermsInL2v1 = _libsbml.NoSBOTermsInL2v1
NoIdOnSpeciesReferenceInL2v1 = _libsbml.NoIdOnSpeciesReferenceInL2v1
NoDelayedEventAssignmentInL2v1 = _libsbml.NoDelayedEventAssignmentInL2v1
StrictUnitsRequiredInL2v1 = _libsbml.StrictUnitsRequiredInL2v1
IntegerSpatialDimensions = _libsbml.IntegerSpatialDimensions
StoichiometryMathNotYetSupported = _libsbml.StoichiometryMathNotYetSupported
PriorityLostFromL3 = _libsbml.PriorityLostFromL3
NonPersistentNotSupported = _libsbml.NonPersistentNotSupported
InitialValueFalseEventNotSupported = _libsbml.InitialValueFalseEventNotSupported
SBOTermNotUniversalInL2v2 = _libsbml.SBOTermNotUniversalInL2v2
NoUnitOffsetInL2v2 = _libsbml.NoUnitOffsetInL2v2
NoKineticLawTimeUnitsInL2v2 = _libsbml.NoKineticLawTimeUnitsInL2v2
NoKineticLawSubstanceUnitsInL2v2 = _libsbml.NoKineticLawSubstanceUnitsInL2v2
NoDelayedEventAssignmentInL2v2 = _libsbml.NoDelayedEventAssignmentInL2v2
ModelSBOBranchChangedBeyondL2v2 = _libsbml.ModelSBOBranchChangedBeyondL2v2
StrictUnitsRequiredInL2v2 = _libsbml.StrictUnitsRequiredInL2v2
StrictSBORequiredInL2v2 = _libsbml.StrictSBORequiredInL2v2
DuplicateAnnotationInvalidInL2v2 = _libsbml.DuplicateAnnotationInvalidInL2v2
NoUnitOffsetInL2v3 = _libsbml.NoUnitOffsetInL2v3
NoKineticLawTimeUnitsInL2v3 = _libsbml.NoKineticLawTimeUnitsInL2v3
NoKineticLawSubstanceUnitsInL2v3 = _libsbml.NoKineticLawSubstanceUnitsInL2v3
NoSpeciesSpatialSizeUnitsInL2v3 = _libsbml.NoSpeciesSpatialSizeUnitsInL2v3
NoEventTimeUnitsInL2v3 = _libsbml.NoEventTimeUnitsInL2v3
NoDelayedEventAssignmentInL2v3 = _libsbml.NoDelayedEventAssignmentInL2v3
ModelSBOBranchChangedBeyondL2v3 = _libsbml.ModelSBOBranchChangedBeyondL2v3
StrictUnitsRequiredInL2v3 = _libsbml.StrictUnitsRequiredInL2v3
StrictSBORequiredInL2v3 = _libsbml.StrictSBORequiredInL2v3
DuplicateAnnotationInvalidInL2v3 = _libsbml.DuplicateAnnotationInvalidInL2v3
NoUnitOffsetInL2v4 = _libsbml.NoUnitOffsetInL2v4
NoKineticLawTimeUnitsInL2v4 = _libsbml.NoKineticLawTimeUnitsInL2v4
NoKineticLawSubstanceUnitsInL2v4 = _libsbml.NoKineticLawSubstanceUnitsInL2v4
NoSpeciesSpatialSizeUnitsInL2v4 = _libsbml.NoSpeciesSpatialSizeUnitsInL2v4
NoEventTimeUnitsInL2v4 = _libsbml.NoEventTimeUnitsInL2v4
ModelSBOBranchChangedInL2v4 = _libsbml.ModelSBOBranchChangedInL2v4
DuplicateAnnotationInvalidInL2v4 = _libsbml.DuplicateAnnotationInvalidInL2v4
NoSpeciesTypeInL3v1 = _libsbml.NoSpeciesTypeInL3v1
NoCompartmentTypeInL3v1 = _libsbml.NoCompartmentTypeInL3v1
NoUnitOffsetInL3v1 = _libsbml.NoUnitOffsetInL3v1
NoKineticLawTimeUnitsInL3v1 = _libsbml.NoKineticLawTimeUnitsInL3v1
NoKineticLawSubstanceUnitsInL3v1 = _libsbml.NoKineticLawSubstanceUnitsInL3v1
NoSpeciesSpatialSizeUnitsInL3v1 = _libsbml.NoSpeciesSpatialSizeUnitsInL3v1
NoEventTimeUnitsInL3v1 = _libsbml.NoEventTimeUnitsInL3v1
ModelSBOBranchChangedInL3v1 = _libsbml.ModelSBOBranchChangedInL3v1
DuplicateAnnotationInvalidInL3v1 = _libsbml.DuplicateAnnotationInvalidInL3v1
NoCompartmentOutsideInL3v1 = _libsbml.NoCompartmentOutsideInL3v1
NoStoichiometryMathInL3v1 = _libsbml.NoStoichiometryMathInL3v1
DoubleExponentNotSupported = _libsbml.DoubleExponentNotSupported
MathMLElementNotSupported = _libsbml.MathMLElementNotSupported
EmptyListOfElementNotSupported = _libsbml.EmptyListOfElementNotSupported
MissingMathElementNotSupported = _libsbml.MissingMathElementNotSupported
MissingTriggerElementNotSupported = _libsbml.MissingTriggerElementNotSupported
BooleanNumericDiscrepancy = _libsbml.BooleanNumericDiscrepancy
IdNameSBaseInL3V2 = _libsbml.IdNameSBaseInL3V2
MissingParticipantsNotSupported = _libsbml.MissingParticipantsNotSupported
ConvertibleMathInitialAssignment = _libsbml.ConvertibleMathInitialAssignment
FastReactionsNotSupported = _libsbml.FastReactionsNotSupported
SpeciesRefIdInMathMLNotSupported = _libsbml.SpeciesRefIdInMathMLNotSupported
InvalidSBMLLevelVersion = _libsbml.InvalidSBMLLevelVersion
InvalidPackageLevelVersion = _libsbml.InvalidPackageLevelVersion
AnnotationNotesNotAllowedLevel1 = _libsbml.AnnotationNotesNotAllowedLevel1
InvalidRuleOrdering = _libsbml.InvalidRuleOrdering
RequiredPackagePresent = _libsbml.RequiredPackagePresent
UnrequiredPackagePresent = _libsbml.UnrequiredPackagePresent
PackageRequiredShouldBeFalse = _libsbml.PackageRequiredShouldBeFalse
SubsUnitsAllowedInKL = _libsbml.SubsUnitsAllowedInKL
TimeUnitsAllowedInKL = _libsbml.TimeUnitsAllowedInKL
FormulaInLevel1KL = _libsbml.FormulaInLevel1KL
L3SubstanceUnitsOnModel = _libsbml.L3SubstanceUnitsOnModel
StoichiometryMathMissingMath = _libsbml.StoichiometryMathMissingMath
TimeUnitsRemoved = _libsbml.TimeUnitsRemoved
BadMathML = _libsbml.BadMathML
FailedMathMLReadOfDouble = _libsbml.FailedMathMLReadOfDouble
FailedMathMLReadOfInteger = _libsbml.FailedMathMLReadOfInteger
FailedMathMLReadOfExponential = _libsbml.FailedMathMLReadOfExponential
FailedMathMLReadOfRational = _libsbml.FailedMathMLReadOfRational
BadMathMLNodeType = _libsbml.BadMathMLNodeType
InvalidMathMLAttribute = _libsbml.InvalidMathMLAttribute
NoTimeSymbolInFunctionDef = _libsbml.NoTimeSymbolInFunctionDef
NoBodyInFunctionDef = _libsbml.NoBodyInFunctionDef
DanglingUnitSIdRef = _libsbml.DanglingUnitSIdRef
RDFMissingAboutTag = _libsbml.RDFMissingAboutTag
RDFEmptyAboutTag = _libsbml.RDFEmptyAboutTag
RDFAboutTagNotMetaid = _libsbml.RDFAboutTagNotMetaid
RDFNotCompleteModelHistory = _libsbml.RDFNotCompleteModelHistory
RDFNotModelHistory = _libsbml.RDFNotModelHistory
AnnotationNotElement = _libsbml.AnnotationNotElement
NestedAnnotationNotAllowed = _libsbml.NestedAnnotationNotAllowed
InconsistentArgUnitsWarnings = _libsbml.InconsistentArgUnitsWarnings
InconsistentPowerUnitsWarnings = _libsbml.InconsistentPowerUnitsWarnings
InconsistentExponUnitsWarnings = _libsbml.InconsistentExponUnitsWarnings
UndeclaredUnits = _libsbml.UndeclaredUnits
UndeclaredTimeUnitsL3 = _libsbml.UndeclaredTimeUnitsL3
UndeclaredExtentUnitsL3 = _libsbml.UndeclaredExtentUnitsL3
UndeclaredObjectUnitsL3 = _libsbml.UndeclaredObjectUnitsL3
CannotVerifyUnitsObjectNoMath = _libsbml.CannotVerifyUnitsObjectNoMath
UnrecognisedSBOTerm = _libsbml.UnrecognisedSBOTerm
ObseleteSBOTerm = _libsbml.ObseleteSBOTerm
IncorrectCompartmentSpatialDimensions = _libsbml.IncorrectCompartmentSpatialDimensions
CompartmentTypeNotValidAttribute = _libsbml.CompartmentTypeNotValidAttribute
ConstantNotValidAttribute = _libsbml.ConstantNotValidAttribute
MetaIdNotValidAttribute = _libsbml.MetaIdNotValidAttribute
SBOTermNotValidAttributeBeforeL2V3 = _libsbml.SBOTermNotValidAttributeBeforeL2V3
InvalidL1CompartmentUnits = _libsbml.InvalidL1CompartmentUnits
L1V1CompartmentVolumeReqd = _libsbml.L1V1CompartmentVolumeReqd
CompartmentTypeNotValidComponent = _libsbml.CompartmentTypeNotValidComponent
ConstraintNotValidComponent = _libsbml.ConstraintNotValidComponent
EventNotValidComponent = _libsbml.EventNotValidComponent
SBOTermNotValidAttributeBeforeL2V2 = _libsbml.SBOTermNotValidAttributeBeforeL2V2
FuncDefNotValidComponent = _libsbml.FuncDefNotValidComponent
InitialAssignNotValidComponent = _libsbml.InitialAssignNotValidComponent
VariableNotValidAttribute = _libsbml.VariableNotValidAttribute
UnitsNotValidAttribute = _libsbml.UnitsNotValidAttribute
ConstantSpeciesNotValidAttribute = _libsbml.ConstantSpeciesNotValidAttribute
SpatialSizeUnitsNotValidAttribute = _libsbml.SpatialSizeUnitsNotValidAttribute
SpeciesTypeNotValidAttribute = _libsbml.SpeciesTypeNotValidAttribute
HasOnlySubsUnitsNotValidAttribute = _libsbml.HasOnlySubsUnitsNotValidAttribute
IdNotValidAttribute = _libsbml.IdNotValidAttribute
NameNotValidAttribute = _libsbml.NameNotValidAttribute
SpeciesTypeNotValidComponent = _libsbml.SpeciesTypeNotValidComponent
StoichiometryMathNotValidComponent = _libsbml.StoichiometryMathNotValidComponent
MultiplierNotValidAttribute = _libsbml.MultiplierNotValidAttribute
OffsetNotValidAttribute = _libsbml.OffsetNotValidAttribute
L3SpatialDimensionsUnset = _libsbml.L3SpatialDimensionsUnset
OperationInterrupted = _libsbml.OperationInterrupted
UnknownCoreAttribute = _libsbml.UnknownCoreAttribute
UnknownPackageAttribute = _libsbml.UnknownPackageAttribute
PackageConversionNotSupported = _libsbml.PackageConversionNotSupported
InvalidTargetLevelVersion = _libsbml.InvalidTargetLevelVersion
L3NotSupported = _libsbml.L3NotSupported
SBMLCodesUpperBound = _libsbml.SBMLCodesUpperBound
LIBSBML_CAT_SBML = _libsbml.LIBSBML_CAT_SBML
LIBSBML_CAT_SBML_L1_COMPAT = _libsbml.LIBSBML_CAT_SBML_L1_COMPAT
LIBSBML_CAT_SBML_L2V1_COMPAT = _libsbml.LIBSBML_CAT_SBML_L2V1_COMPAT
LIBSBML_CAT_SBML_L2V2_COMPAT = _libsbml.LIBSBML_CAT_SBML_L2V2_COMPAT
LIBSBML_CAT_GENERAL_CONSISTENCY = _libsbml.LIBSBML_CAT_GENERAL_CONSISTENCY
LIBSBML_CAT_IDENTIFIER_CONSISTENCY = _libsbml.LIBSBML_CAT_IDENTIFIER_CONSISTENCY
LIBSBML_CAT_UNITS_CONSISTENCY = _libsbml.LIBSBML_CAT_UNITS_CONSISTENCY
LIBSBML_CAT_MATHML_CONSISTENCY = _libsbml.LIBSBML_CAT_MATHML_CONSISTENCY
LIBSBML_CAT_SBO_CONSISTENCY = _libsbml.LIBSBML_CAT_SBO_CONSISTENCY
LIBSBML_CAT_OVERDETERMINED_MODEL = _libsbml.LIBSBML_CAT_OVERDETERMINED_MODEL
LIBSBML_CAT_SBML_L2V3_COMPAT = _libsbml.LIBSBML_CAT_SBML_L2V3_COMPAT
LIBSBML_CAT_MODELING_PRACTICE = _libsbml.LIBSBML_CAT_MODELING_PRACTICE
LIBSBML_CAT_INTERNAL_CONSISTENCY = _libsbml.LIBSBML_CAT_INTERNAL_CONSISTENCY
LIBSBML_CAT_SBML_L2V4_COMPAT = _libsbml.LIBSBML_CAT_SBML_L2V4_COMPAT
LIBSBML_CAT_SBML_L3V1_COMPAT = _libsbml.LIBSBML_CAT_SBML_L3V1_COMPAT
LIBSBML_CAT_SBML_L3V2_COMPAT = _libsbml.LIBSBML_CAT_SBML_L3V2_COMPAT
LIBSBML_CAT_SBML_COMPATIBILITY = _libsbml.LIBSBML_CAT_SBML_COMPATIBILITY
LIBSBML_SEV_SCHEMA_ERROR = _libsbml.LIBSBML_SEV_SCHEMA_ERROR
LIBSBML_SEV_GENERAL_WARNING = _libsbml.LIBSBML_SEV_GENERAL_WARNING
LIBSBML_SEV_NOT_APPLICABLE = _libsbml.LIBSBML_SEV_NOT_APPLICABLE
class SBMLError(XMLError):
    """

    An error, warning or other diagnostic.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    When a libSBML operation on SBML content results in an error, or when
    there is something wrong with the SBML content, the problems are
    reported as SBMLError objects.  These are generally stored in an
    SBMLErrorLog object; this log object, in turn, is kept in the
    SBMLDocument object containing the SBML content.  Applications can
    obtain the list of logged errors using SBMLDocument.getErrorLog() and
    then use the methods provided by SBMLErrorLog to access individual
    SBMLError objects.  (Note that despite the word 'error' in the name,
    SBMLError objects are used to represent not only 'true' errors, but
    also warnings and some informational diagnostics.  The name is a
    historical hold-over from early versions of libSBML, in which the
    object really was only used to report errors.)

    Each SBMLError object instance has an identification number that
    identifies the nature of the problem.  This 'error id' number will be
    up to five digits long, and it will come from one of two sets of
    static integer constants defined in the interface class libsbml:
    either the SBML error identifiers  (described below) or the XML error
    identifiers (described in the documentation for the class XMLError).
    The former set of constants includes all the SBML validation rule
    numbers listed in the appendices of the SBML specification documents,
    as well as some additional libSBML-specific error codes.

    Error codes are useful mainly for software.  For human readers,
    SBMLError also includes text messages that describe the nature of a
    given problem.  The messages can be accessed using
    SBMLError.getShortMessage() and SBMLError.getMessage().  The former
    provides a brief one-line description of the issue, while
    SBMLError.getMessage() provides a more detailed text, including (if
    appropriate) references to sections of the SBML specifications where
    relevant topics are discussed.  These text strings are suitable for
    displaying to human users.

    An SBMLError object also contains a category code; its value may be
    retrieved using the method SBMLError.getCategory().  Category values
    are drawn from a set of static integer constants defined in libsbml
    and having names beginning with the characters LIBSBML_CAT_.  The list
    of possible codes is described in a separate section below.
    Categories are used to partition errors into distinct conceptual
    groups.  This is principally used by the libSBML validation system to
    group classes of validation checks.  For example,
    LIBSBML_CAT_IDENTIFIER_CONSISTENCY is the category for tests that
    check identifier consistency; LIBSBML_CAT_MATHML_CONSISTENCY is the
    category for MathML consistency checking; and so on.

    In addition, SBMLError also has a severity code.  Its value may be
    retrieved using the method SBMLError.getSeverity().  The possible
    severity values are the same as those reported by XMLError. Severity
    levels currently range from informational (LIBSBML_SEV_INFO) to fatal
    errors (LIBSBML_SEV_FATAL). They can be used by an application to
    evaluate how serious a given problem is.

    SBMLError also tracks the Level 3 package extension, if any, was
    responsible for a given warning or error.  Each diagnostic code logged
    by an libSBML extension for SBML Level 3 packages includes a record of
    the package that logged it.  It can be retrieved using
    SBMLError.getPackage().  The information is a simple text string; the
    string will be the nickname of the package, such as ''comp'' for the
    Hierarchical Model Composition package, ''fbc'' for the Flux Balance
    Constraints package, and so on.  If the value returned by
    SBMLError.getPackage() is an empty string or has the value ''core','
    then the error came from libSBML core.

    Finally, SBMLError records the line and column near where the problem
    occurred in the SBML content.  The values may be retrieved using the
    methods SBMLError.getLine() and SBMLError.getColumn().  We say 'near',
    because a lot of factors affect how accurate the line/column
    information ultimately is.  For example, different XML parsers have
    different conventions for which line and column number they report for
    a particular problem (which makes a difference when a problem involves
    an opening XML tag on one line and a closing tag on another line).  In
    some situations, some parsers report invalid line and/or column
    numbers altogether.  If this occurs, libSBML sets the line and/or
    column number in the SBMLError object to the the value of the maximum
    unsigned long integer representable on the platform where libSBML is
    running.  (This is equal to the constant named ULONG_MAX in C and
    C++.) The probability that a true line or column number in an SBML
    model would equal this value is vanishingly small; thus, if an
    application encounters these values in an XMLError object, it can
    assume no valid line/column number could be provided by libSBML in
    that situation.

    Error codes associated with SBMLError objects
    ......................................................................

    The error and warning codes returned by libSBML are listed in the
    table below.  The method SBMLError.getErrorId() returns the error code
    of a given SBMLError object instance.  In the libSBML Python language
    interface, these error identifiers are currently implemented as static
    integer constants defined in the interface class libsbml.

    In this table, the right-hand columns titled 'L1V1', 'L1V2', etc.
    refer to Levels and Versions of the SBML specifications, and the
    entries in each column refer to whether the severity of the condition
    in that particular Level+Version of SBML.  The codes stand for the
    following:

         = Not applicable 
         = Warning        
         = Error          
         = Fatal

    The text shown in the 'Meaning' is the text returned by the
    SBMLError.getShortMessage() method on a given SBMLError object.  A
    longer and (hopefully) clearer explanation of the issue is returned by
    SBMLError.getMessage().

    The error codes come from different lists depending on whether they're
    from libSBML core or from an SBML Level 3 package extension.

    However, in the language interfaces other than C++, all libSBML error
    codes are ultimately represented as integer constants rather than
    separate enumerations lists, and they are all stored in a single
    interface class.  Codes from different libSBML extensions have names
    that begin with the package's nickname, such as Qual for the
    Qualitative Models package, Layout for the Layout package, and so on.
    If the name of a code does not begin with one of the package nicknames
    (Layout, Fbc, Comp, Qual, etc.), then it is a code from libSBML core.

      +-------------------------------------------+------------------------------------------------------------------------------------------------------+-------+-------+-------+-------+-------+-------+-------+-------+
      | Enumerator                                | Meaning                                                                                              | L1 V1 | L1 V2 | L2 V1 | L2 V2 | L2 V3 | L2 V4 | L3 V1 | L3 V2 |
      +-------------------------------------------+------------------------------------------------------------------------------------------------------+-------+-------+-------+-------+-------+-------+-------+-------+
      | XMLUnknownError                           | Unknown error                                                                                        |       |       |       |       |       |       |       |       |
      | XMLOutOfMemory                            | Out of memory                                                                                        |       |       |       |       |       |       |       |       |
      | XMLFileUnreadable                         | File unreadable                                                                                      |       |       |       |       |       |       |       |       |
      | XMLFileUnwritable                         | File unwritable                                                                                      |       |       |       |       |       |       |       |       |
      | XMLFileOperationError                     | File operation error                                                                                 |       |       |       |       |       |       |       |       |
      | XMLNetworkAccessError                     | Network access error                                                                                 |       |       |       |       |       |       |       |       |
      | InternalXMLParserError                    | Internal XML parser error                                                                            |       |       |       |       |       |       |       |       |
      | UnrecognizedXMLParserCode                 | Unrecognized XML parser code                                                                         |       |       |       |       |       |       |       |       |
      | XMLTranscoderError                        | Transcoder error                                                                                     |       |       |       |       |       |       |       |       |
      | MissingXMLDecl                            | Missing XML declaration                                                                              |       |       |       |       |       |       |       |       |
      | MissingXMLEncoding                        | Missing XML encoding attribute                                                                       |       |       |       |       |       |       |       |       |
      | BadXMLDecl                                | Bad XML declaration                                                                                  |       |       |       |       |       |       |       |       |
      | BadXMLDOCTYPE                             | Bad XML DOCTYPE                                                                                      |       |       |       |       |       |       |       |       |
      | InvalidCharInXML                          | Invalid character                                                                                    |       |       |       |       |       |       |       |       |
      | BadlyFormedXML                            | Badly formed XML                                                                                     |       |       |       |       |       |       |       |       |
      | UnclosedXMLToken                          | Unclosed token                                                                                       |       |       |       |       |       |       |       |       |
      | InvalidXMLConstruct                       | Invalid XML construct                                                                                |       |       |       |       |       |       |       |       |
      | XMLTagMismatch                            | XML tag mismatch                                                                                     |       |       |       |       |       |       |       |       |
      | DuplicateXMLAttribute                     | Duplicate attribute                                                                                  |       |       |       |       |       |       |       |       |
      | UndefinedXMLEntity                        | Undefined XML entity                                                                                 |       |       |       |       |       |       |       |       |
      | BadProcessingInstruction                  | Bad XML processing instruction                                                                       |       |       |       |       |       |       |       |       |
      | BadXMLPrefix                              | Bad XML prefix                                                                                       |       |       |       |       |       |       |       |       |
      | BadXMLPrefixValue                         | Bad XML prefix value                                                                                 |       |       |       |       |       |       |       |       |
      | MissingXMLRequiredAttribute               | Missing required attribute                                                                           |       |       |       |       |       |       |       |       |
      | XMLAttributeTypeMismatch                  | Attribute type mismatch                                                                              |       |       |       |       |       |       |       |       |
      | XMLBadUTF8Content                         | Bad UTF8 content                                                                                     |       |       |       |       |       |       |       |       |
      | MissingXMLAttributeValue                  | Missing attribute value                                                                              |       |       |       |       |       |       |       |       |
      | BadXMLAttributeValue                      | Bad attribute value                                                                                  |       |       |       |       |       |       |       |       |
      | BadXMLAttribute                           | Bad XML attribute                                                                                    |       |       |       |       |       |       |       |       |
      | UnrecognizedXMLElement                    | Unrecognized XML element                                                                             |       |       |       |       |       |       |       |       |
      | BadXMLComment                             | Bad XML comment                                                                                      |       |       |       |       |       |       |       |       |
      | BadXMLDeclLocation                        | Bad XML declaration location                                                                         |       |       |       |       |       |       |       |       |
      | XMLUnexpectedEOF                          | Unexpected EOF                                                                                       |       |       |       |       |       |       |       |       |
      | BadXMLIDValue                             | Bad XML ID value                                                                                     |       |       |       |       |       |       |       |       |
      | BadXMLIDRef                               | Bad XML IDREF                                                                                        |       |       |       |       |       |       |       |       |
      | UninterpretableXMLContent                 | Uninterpretable XML content                                                                          |       |       |       |       |       |       |       |       |
      | BadXMLDocumentStructure                   | Bad XML document structure                                                                           |       |       |       |       |       |       |       |       |
      | InvalidAfterXMLContent                    | Invalid content after XML content                                                                    |       |       |       |       |       |       |       |       |
      | XMLExpectedQuotedString                   | Expected quoted string                                                                               |       |       |       |       |       |       |       |       |
      | XMLEmptyValueNotPermitted                 | Empty value not permitted                                                                            |       |       |       |       |       |       |       |       |
      | XMLBadNumber                              | Bad number                                                                                           |       |       |       |       |       |       |       |       |
      | XMLBadColon                               | Colon character not permitted                                                                        |       |       |       |       |       |       |       |       |
      | MissingXMLElements                        | Missing XML elements                                                                                 |       |       |       |       |       |       |       |       |
      | XMLContentEmpty                           | Empty XML content                                                                                    |       |       |       |       |       |       |       |       |
      | UnknownError                              | Encountered unknown internal libSBML error                                                           |       |       |       |       |       |       |       |       |
      | NotUTF8                                   | File does not use UTF-8 encoding                                                                     |       |       |       |       |       |       |       |       |
      | UnrecognizedElement                       | Encountered unrecognized element                                                                     |       |       |       |       |       |       |       |       |
      | NotSchemaConformant                       | Document does not conform to the SBML XML schema                                                     |       |       |       |       |       |       |       |       |
      | L3NotSchemaConformant                     | Document is not well-formed XML                                                                      |       |       |       |       |       |       |       |       |
      | InvalidMathElement                        | Invalid MathML                                                                                       |       |       |       |       |       |       |       |       |
      | DisallowedMathMLSymbol                    | Disallowed MathML symbol found                                                                       |       |       |       |       |       |       |       |       |
      | DisallowedMathMLEncodingUse               | Use of the MathML 'encoding' attribute is not allowed on this element                                |       |       |       |       |       |       |       |       |
      | DisallowedDefinitionURLUse                | Use of the MathML 'definitionURL' attribute is not allowed on this element                           |       |       |       |       |       |       |       |       |
      | BadCsymbolDefinitionURLValue              | Invalid <csymbol> 'definitionURL' attribute value                                                    |       |       |       |       |       |       |       |       |
      | DisallowedMathTypeAttributeUse            | Use of the MathML 'type' attribute is not allowed on this element                                    |       |       |       |       |       |       |       |       |
      | DisallowedMathTypeAttributeValue          | Disallowed MathML 'type' attribute value                                                             |       |       |       |       |       |       |       |       |
      | LambdaOnlyAllowedInFunctionDef            | Use of <lambda> not permitted outside of FunctionDefinition objects                                  |       |       |       |       |       |       |       |       |
      | BooleanOpsNeedBooleanArgs                 | Non-Boolean argument given to Boolean operator                                                       |       |       |       |       |       |       |       |       |
      | NumericOpsNeedNumericArgs                 | Non-numerical argument given to numerical operator                                                   |       |       |       |       |       |       |       |       |
      | ArgsToEqNeedSameType                      | Arguments to <eq> and <neq> must have the same data types                                            |       |       |       |       |       |       |       |       |
      | PiecewiseNeedsConsistentTypes             | Terms in a <piecewise> expression must have consistent data types                                    |       |       |       |       |       |       |       |       |
      | PieceNeedsBoolean                         | The second argument of a <piece> expression must yield a Boolean value                               |       |       |       |       |       |       |       |       |
      | ApplyCiMustBeUserFunction                 | A <ci> element in this context must refer to a function definition                                   |       |       |       |       |       |       |       |       |
      | ApplyCiMustBeModelComponent               | A <ci> element in this context must refer to a model component                                       |       |       |       |       |       |       |       |       |
      | KineticLawParametersAreLocalOnly          | Cannot use a KineticLaw local parameter outside of its local scope                                   |       |       |       |       |       |       |       |       |
      | MathResultMustBeNumeric                   | A formula's result in this context must be a numerical value                                         |       |       |       |       |       |       |       |       |
      | OpsNeedCorrectNumberOfArgs                | Incorrect number of arguments given to MathML operator                                               |       |       |       |       |       |       |       |       |
      | InvalidNoArgsPassedToFunctionDef          | Incorrect number of arguments given to function invocation                                           |       |       |       |       |       |       |       |       |
      | DisallowedMathUnitsUse                    | Attribute 'units' is only permitted on <cn> elements                                                 |       |       |       |       |       |       |       |       |
      | InvalidUnitsValue                         | Invalid value given for the 'units' attribute                                                        |       |       |       |       |       |       |       |       |
      | CiCannotReference0DCompartment            | A <ci> element cannot reference a 0D compartment                                                     |       |       |       |       |       |       |       |       |
      | RateOfTargetMustBeCi                      | A 'rateOf' <csymbol> must target only a single <ci> element                                          |       |       |       |       |       |       |       |       |
      | RateOfTargetCannotBeAssigned              | The target of a 'rateOf' <csymbol> cannot be assigned                                                |       |       |       |       |       |       |       |       |
      | RateOfSpeciesTargetCompartmentNot         | Compartments of non-substance <species> referenced by 'rateOf' must not vary                         |       |       |       |       |       |       |       |       |
      | DuplicateComponentId                      | Duplicate 'id' attribute value                                                                       |       |       |       |       |       |       |       |       |
      | DuplicateUnitDefinitionId                 | Duplicate unit definition 'id' attribute value                                                       |       |       |       |       |       |       |       |       |
      | DuplicateLocalParameterId                 | Duplicate local parameter 'id' attribute value                                                       |       |       |       |       |       |       |       |       |
      | MultipleAssignmentOrRateRules             | Multiple rules for the same variable are not allowed                                                 |       |       |       |       |       |       |       |       |
      | MultipleEventAssignmentsForId             | Multiple event assignments for the same variable are not allowed                                     |       |       |       |       |       |       |       |       |
      | EventAndAssignmentRuleForId               | An event assignment and an assignment rule must not have the same value for 'variable'               |       |       |       |       |       |       |       |       |
      | DuplicateMetaId                           | Duplicate 'metaid' attribute value                                                                   |       |       |       |       |       |       |       |       |
      | InvalidSBOTermSyntax                      | Invalid syntax for an 'sboTerm' attribute value                                                      |       |       |       |       |       |       |       |       |
      | InvalidMetaidSyntax                       | Invalid syntax for a 'metaid' attribute value                                                        |       |       |       |       |       |       |       |       |
      | InvalidIdSyntax                           | Invalid syntax for an 'id' attribute value                                                           |       |       |       |       |       |       |       |       |
      | InvalidUnitIdSyntax                       | Invalid syntax for the identifier of a unit                                                          |       |       |       |       |       |       |       |       |
      | InvalidNameSyntax                         | Invalid syntax for a 'name' attribute value                                                          |       |       |       |       |       |       |       |       |
      | DanglingUnitReference                     | Dangling reference to a unit.                                                                        |       |       |       |       |       |       |       |       |
      | MissingAnnotationNamespace                | Missing declaration of the XML namespace for the annotation                                          |       |       |       |       |       |       |       |       |
      | DuplicateAnnotationNamespaces             | Multiple annotations using the same XML namespace                                                    |       |       |       |       |       |       |       |       |
      | SBMLNamespaceInAnnotation                 | The SBML XML namespace cannot be used in an Annotation object                                        |       |       |       |       |       |       |       |       |
      | MultipleAnnotations                       | Only one Annotation object is permitted under a given SBML object                                    |       |       |       |       |       |       |       |       |
      | InconsistentArgUnits                      | The units of the function call's arguments are not consistent with its definition                    |       |       |       |       |       |       |       |       |
      | InconsistentKineticLawUnitsL3             | The kinetic law's units are inconsistent with those of other kinetic laws in the model               |       |       |       |       |       |       |       |       |
      | AssignRuleCompartmentMismatch             | Mismatched units in assignment rule for compartment                                                  |       |       |       |       |       |       |       |       |
      | AssignRuleSpeciesMismatch                 | Mismatched units in assignment rule for species                                                      |       |       |       |       |       |       |       |       |
      | AssignRuleParameterMismatch               | Mismatched units in assignment rule for parameter                                                    |       |       |       |       |       |       |       |       |
      | AssignRuleStoichiometryMismatch           | Mismatched units in assignment rule for stoichiometry                                                |       |       |       |       |       |       |       |       |
      | InitAssignCompartmenMismatch              | Mismatched units in initial assignment to compartment                                                |       |       |       |       |       |       |       |       |
      | InitAssignSpeciesMismatch                 | Mismatched units in initial assignment to species                                                    |       |       |       |       |       |       |       |       |
      | InitAssignParameterMismatch               | Mismatched units in initial assignment to parameter                                                  |       |       |       |       |       |       |       |       |
      | InitAssignStoichiometryMismatch           | Mismatched units in initial assignment to stoichiometry                                              |       |       |       |       |       |       |       |       |
      | RateRuleCompartmentMismatch               | Mismatched units in rate rule for compartment                                                        |       |       |       |       |       |       |       |       |
      | RateRuleSpeciesMismatch                   | Mismatched units in rate rule for species                                                            |       |       |       |       |       |       |       |       |
      | RateRuleParameterMismatch                 | Mismatched units in rate rule for parameter                                                          |       |       |       |       |       |       |       |       |
      | RateRuleStoichiometryMismatch             | Mismatched units in rate rule for stoichiometry                                                      |       |       |       |       |       |       |       |       |
      | KineticLawNotSubstancePerTime             | The units of the kinetic law are not 'substance'/'time'                                              |       |       |       |       |       |       |       |       |
      | SpeciesInvalidExtentUnits                 | The species' units are not consistent with units of extent                                           |       |       |       |       |       |       |       |       |
      | DelayUnitsNotTime                         | The units of the delay expression are not units of time                                              |       |       |       |       |       |       |       |       |
      | EventAssignCompartmentMismatch            | Mismatched units in event assignment for compartment                                                 |       |       |       |       |       |       |       |       |
      | EventAssignSpeciesMismatch                | Mismatched units in event assignment for species                                                     |       |       |       |       |       |       |       |       |
      | EventAssignParameterMismatch              | Mismatched units in event assignment for parameter                                                   |       |       |       |       |       |       |       |       |
      | EventAssignStoichiometryMismatch          | Mismatched units in event assignment for stoichiometry                                               |       |       |       |       |       |       |       |       |
      | PriorityUnitsNotDimensionless             | The units of a priority expression must be 'dimensionless'                                           |       |       |       |       |       |       |       |       |
      | OverdeterminedSystem                      | The model is overdetermined                                                                          |       |       |       |       |       |       |       |       |
      | InvalidModelSBOTerm                       | Invalid 'sboTerm' attribute value for a Model object                                                 |       |       |       |       |       |       |       |       |
      | InvalidFunctionDefSBOTerm                 | Invalid 'sboTerm' attribute value for a FunctionDefinition object                                    |       |       |       |       |       |       |       |       |
      | InvalidParameterSBOTerm                   | Invalid 'sboTerm' attribute value for a Parameter object                                             |       |       |       |       |       |       |       |       |
      | InvalidInitAssignSBOTerm                  | Invalid 'sboTerm' attribute value for an InitialAssignment object                                    |       |       |       |       |       |       |       |       |
      | InvalidRuleSBOTerm                        | Invalid 'sboTerm' attribute value for a Rule object                                                  |       |       |       |       |       |       |       |       |
      | InvalidConstraintSBOTerm                  | Invalid 'sboTerm' attribute value for a Constraint object                                            |       |       |       |       |       |       |       |       |
      | InvalidReactionSBOTerm                    | Invalid 'sboTerm' attribute value for a Reaction object                                              |       |       |       |       |       |       |       |       |
      | InvalidSpeciesReferenceSBOTerm            | Invalid 'sboTerm' attribute value for a SpeciesReference object                                      |       |       |       |       |       |       |       |       |
      | InvalidKineticLawSBOTerm                  | Invalid 'sboTerm' attribute value for a KineticLaw object                                            |       |       |       |       |       |       |       |       |
      | InvalidEventSBOTerm                       | Invalid 'sboTerm' attribute value for an Event object                                                |       |       |       |       |       |       |       |       |
      | InvalidEventAssignmentSBOTerm             | Invalid 'sboTerm' attribute value for an EventAssignment object                                      |       |       |       |       |       |       |       |       |
      | InvalidCompartmentSBOTerm                 | Invalid 'sboTerm' attribute value for a Compartment object                                           |       |       |       |       |       |       |       |       |
      | InvalidSpeciesSBOTerm                     | Invalid 'sboTerm' attribute value for a Species object                                               |       |       |       |       |       |       |       |       |
      | InvalidCompartmentTypeSBOTerm             | Invalid 'sboTerm' attribute value for a CompartmentType object                                       |       |       |       |       |       |       |       |       |
      | InvalidSpeciesTypeSBOTerm                 | Invalid 'sboTerm' attribute value for a SpeciesType object                                           |       |       |       |       |       |       |       |       |
      | InvalidTriggerSBOTerm                     | Invalid 'sboTerm' attribute value for an Event Trigger object                                        |       |       |       |       |       |       |       |       |
      | InvalidDelaySBOTerm                       | Invalid 'sboTerm' attribute value for an Event Delay object                                          |       |       |       |       |       |       |       |       |
      | InvalidLocalParameterSBOTerm              | Invalid 'sboTerm' attribute value for a LocalParameter object                                        |       |       |       |       |       |       |       |       |
      | InvalidSBMLElementSBOTerm                 | Invalid 'sboTerm' attribute value for the <sbml> element                                             |       |       |       |       |       |       |       |       |
      | NotesNotInXHTMLNamespace                  | Notes must be placed in the XHTML XML namespace                                                      |       |       |       |       |       |       |       |       |
      | NotesContainsXMLDecl                      | XML declarations are not permitted in Notes objects                                                  |       |       |       |       |       |       |       |       |
      | NotesContainsDOCTYPE                      | XML DOCTYPE elements are not permitted in Notes objects                                              |       |       |       |       |       |       |       |       |
      | InvalidNotesContent                       | Invalid notes content found                                                                          |       |       |       |       |       |       |       |       |
      | OnlyOneNotesElementAllowed                | Only one Notes subobject is permitted on a given SBML object                                         |       |       |       |       |       |       |       |       |
      | InvalidNamespaceOnSBML                    | Invalid XML namespace for the SBML container element                                                 |       |       |       |       |       |       |       |       |
      | MissingOrInconsistentLevel                | Missing or inconsistent value for the 'level' attribute                                              |       |       |       |       |       |       |       |       |
      | MissingOrInconsistentVersion              | Missing or inconsistent value for the 'version' attribute                                            |       |       |       |       |       |       |       |       |
      | PackageNSMustMatch                        | Inconsistent or invalid SBML Level/Version for the package namespace declaration                     |       |       |       |       |       |       |       |       |
      | LevelPositiveInteger                      | The 'level' attribute must have a positive integer value                                             |       |       |       |       |       |       |       |       |
      | VersionPositiveInteger                    | The 'version' attribute must have a positive integer value                                           |       |       |       |       |       |       |       |       |
      | AllowedAttributesOnSBML                   | Invalid attribute found on the SBML container element                                                |       |       |       |       |       |       |       |       |
      | L3PackageOnLowerSBML                      | An L3 package ns found on the SBML container element                                                 |       |       |       |       |       |       |       |       |
      | MissingModel                              | No model definition found                                                                            |       |       |       |       |       |       |       |       |
      | IncorrectOrderInModel                     | Incorrect ordering of components within the Model object                                             |       |       |       |       |       |       |       |       |
      | EmptyListElement                          | Empty ListOf___ object found                                                                         |       |       |       |       |       |       |       |       |
      | NeedCompartmentIfHaveSpecies              | The presence of a species requires a compartment                                                     |       |       |       |       |       |       |       |       |
      | OneOfEachListOf                           | Only one of each kind of ListOf___ object is allowed inside a Model object                           |       |       |       |       |       |       |       |       |
      | OnlyFuncDefsInListOfFuncDefs              | Only FunctionDefinition, Notes and Annotation objects are allowed in ListOfFunctionDefinitions       |       |       |       |       |       |       |       |       |
      | OnlyUnitDefsInListOfUnitDefs              | Only UnitDefinition, Notes and Annotation objects are allowed in ListOfUnitDefinitions objects       |       |       |       |       |       |       |       |       |
      | OnlyCompartmentsInListOfCompartments      | Only Compartment, Notes and Annotation objects are allowed in ListOfCompartments objects             |       |       |       |       |       |       |       |       |
      | OnlySpeciesInListOfSpecies                | Only Species, Notes and Annotation objects are allowed in ListOfSpecies objects                      |       |       |       |       |       |       |       |       |
      | OnlyParametersInListOfParameters          | Only Parameter, Notes and Annotation objects are allowed in ListOfParameters objects                 |       |       |       |       |       |       |       |       |
      | OnlyInitAssignsInListOfInitAssigns        | Only InitialAssignment, Notes and Annotation objects are allowed in ListOfInitialAssignments objects |       |       |       |       |       |       |       |       |
      | OnlyRulesInListOfRules                    | Only Rule, Notes and Annotation objects are allowed in ListOfRules objects                           |       |       |       |       |       |       |       |       |
      | OnlyConstraintsInListOfConstraints        | Only Constraint, Notes and Annotation objects are allowed in ListOfConstraints objects               |       |       |       |       |       |       |       |       |
      | OnlyReactionsInListOfReactions            | Only Reaction, Notes and Annotation objects are allowed in ListOfReactions objects                   |       |       |       |       |       |       |       |       |
      | OnlyEventsInListOfEvents                  | Only Event, Notes and Annotation objects are allowed in ListOfEvents objects                         |       |       |       |       |       |       |       |       |
      | L3ConversionFactorOnModel                 | A 'conversionFactor' attribute value must reference a Parameter object                               |       |       |       |       |       |       |       |       |
      | L3TimeUnitsOnModel                        | Invalid 'timeUnits' attribute value                                                                  |       |       |       |       |       |       |       |       |
      | L3VolumeUnitsOnModel                      | Invalid 'volumeUnits' attribute value                                                                |       |       |       |       |       |       |       |       |
      | L3AreaUnitsOnModel                        | Invalid 'areaUnits' attribute value                                                                  |       |       |       |       |       |       |       |       |
      | L3LengthUnitsOnModel                      | Invalid 'lengthUnits' attribute value                                                                |       |       |       |       |       |       |       |       |
      | L3ExtentUnitsOnModel                      | Invalid 'extentUnits' attribute value                                                                |       |       |       |       |       |       |       |       |
      | AllowedAttributesOnModel                  | Invalid attribute found on the Model object                                                          |       |       |       |       |       |       |       |       |
      | AllowedAttributesOnListOfFuncs            | Invalid attribute found on the ListOfFunctionDefinitions object                                      |       |       |       |       |       |       |       |       |
      | AllowedAttributesOnListOfUnitDefs         | Invalid attribute found on the ListOfUnitDefinitions object                                          |       |       |       |       |       |       |       |       |
      | AllowedAttributesOnListOfComps            | Invalid attribute found on the ListOfCompartments object                                             |       |       |       |       |       |       |       |       |
      | AllowedAttributesOnListOfSpecies          | Invalid attribute found on the ListOfSpecies object                                                  |       |       |       |       |       |       |       |       |
      | AllowedAttributesOnListOfParams           | Invalid attribute found on the ListOfParameters object                                               |       |       |       |       |       |       |       |       |
      | AllowedAttributesOnListOfInitAssign       | Invalid attribute found on the ListOfInitialAssignments object                                       |       |       |       |       |       |       |       |       |
      | AllowedAttributesOnListOfRules            | Invalid attribute found on the ListOfRules object                                                    |       |       |       |       |       |       |       |       |
      | AllowedAttributesOnListOfConstraints      | Invalid attribute found on the ListOfConstraints object                                              |       |       |       |       |       |       |       |       |
      | AllowedAttributesOnListOfReactions        | Invalid attribute found on the ListOfReactions object                                                |       |       |       |       |       |       |       |       |
      | AllowedAttributesOnListOfEvents           | Invalid attribute found on the ListOfEvents object                                                   |       |       |       |       |       |       |       |       |
      | L3V2SubstanceUnitsOnModel                 | Invalid 'substanceUnits' attribute value                                                             |       |       |       |       |       |       |       |       |
      | FunctionDefMathNotLambda                  | Invalid expression found in the function definition                                                  |       |       |       |       |       |       |       |       |
      | InvalidApplyCiInLambda                    | Invalid forward reference in the MathML <apply><ci>...</ci></apply> expression                       |       |       |       |       |       |       |       |       |
      | RecursiveFunctionDefinition               | Recursive function definitions are not permitted                                                     |       |       |       |       |       |       |       |       |
      | InvalidCiInLambda                         | Invalid <ci> reference found inside the <lambda> mathematical formula                                |       |       |       |       |       |       |       |       |
      | InvalidFunctionDefReturnType              | A function's return type must be either a number or a Boolean                                        |       |       |       |       |       |       |       |       |
      | OneMathElementPerFunc                     | A FunctionDefinition object may contain one <math> element                                           |       |       |       |       |       |       |       |       |
      | AllowedAttributesOnFunc                   | Invalid attribute found on the FunctionDefinition object                                             |       |       |       |       |       |       |       |       |
      | InvalidUnitDefId                          | Invalid 'id' attribute value for a UnitDefinition object                                             |       |       |       |       |       |       |       |       |
      | InvalidSubstanceRedefinition              | Invalid redefinition of built-in type 'substance'                                                    |       |       |       |       |       |       |       |       |
      | InvalidLengthRedefinition                 | Invalid redefinition of built-in type 'length'                                                       |       |       |       |       |       |       |       |       |
      | InvalidAreaRedefinition                   | Invalid redefinition of built-in type name 'area'                                                    |       |       |       |       |       |       |       |       |
      | InvalidTimeRedefinition                   | Invalid redefinition of built-in type name 'time'                                                    |       |       |       |       |       |       |       |       |
      | InvalidVolumeRedefinition                 | Invalid redefinition of built-in type name 'volume'                                                  |       |       |       |       |       |       |       |       |
      | VolumeLitreDefExponentNotOne              | Must use 'exponent'=1 when defining 'volume' in terms of litres                                      |       |       |       |       |       |       |       |       |
      | VolumeMetreDefExponentNot3                | Must use 'exponent'=3 when defining 'volume' in terms of metres                                      |       |       |       |       |       |       |       |       |
      | EmptyListOfUnits                          | An empty list of Unit objects is not permitted in a UnitDefinition object                            |       |       |       |       |       |       |       |       |
      | InvalidUnitKind                           | Invalid value for the 'kind' attribute of a UnitDefinition object                                    |       |       |       |       |       |       |       |       |
      | OffsetNoLongerValid                       | Unit attribute 'offset' is not supported in this Level+Version of SBML                               |       |       |       |       |       |       |       |       |
      | CelsiusNoLongerValid                      | Unit name 'Celsius' is not defined in this Level+Version of SBML                                     |       |       |       |       |       |       |       |       |
      | EmptyUnitListElement                      | A ListOfUnits object must not be empty                                                               |       |       |       |       |       |       |       |       |
      | OneListOfUnitsPerUnitDef                  | At most one ListOfUnits object is allowed inside a UnitDefinition object                             |       |       |       |       |       |       |       |       |
      | OnlyUnitsInListOfUnits                    | Only Unit, Notes and Annotation objects are allowed in ListOfUnits objects                           |       |       |       |       |       |       |       |       |
      | AllowedAttributesOnUnitDefinition         | Invalid attribute found on the UnitDefinition object                                                 |       |       |       |       |       |       |       |       |
      | AllowedAttributesOnListOfUnits            | Invalid attribute found on the ListOfUnits object                                                    |       |       |       |       |       |       |       |       |
      | AllowedAttributesOnUnit                   | Invalid attribute found on the Unit object                                                           |       |       |       |       |       |       |       |       |
      | ZeroDimensionalCompartmentSize            | Invalid use of the 'size' attribute for a zero-dimensional compartment                               |       |       |       |       |       |       |       |       |
      | ZeroDimensionalCompartmentUnits           | Invalid use of the 'units' attribute for a zero-dimensional compartment                              |       |       |       |       |       |       |       |       |
      | ZeroDimensionalCompartmentConst           | Zero-dimensional compartments must be defined to be constant                                         |       |       |       |       |       |       |       |       |
      | UndefinedOutsideCompartment               | Invalid value for the 'outside' attribute of a Compartment object                                    |       |       |       |       |       |       |       |       |
      | RecursiveCompartmentContainment           | Recursive nesting of compartments via the 'outside' attribute is not permitted                       |       |       |       |       |       |       |       |       |
      | ZeroDCompartmentContainment               | Invalid nesting of zero-dimensional compartments                                                     |       |       |       |       |       |       |       |       |
      | Invalid1DCompartmentUnits                 | Invalid value for the 'units' attribute of a one-dimensional compartment                             |       |       |       |       |       |       |       |       |
      | Invalid2DCompartmentUnits                 | Invalid value for the 'units' attribute of a two-dimensional compartment                             |       |       |       |       |       |       |       |       |
      | Invalid3DCompartmentUnits                 | Invalid value for the 'units' attribute of a three-dimensional compartment                           |       |       |       |       |       |       |       |       |
      | InvalidCompartmentTypeRef                 | Invalid value for the 'compartmentType' attribute of a compartment                                   |       |       |       |       |       |       |       |       |
      | OneDimensionalCompartmentUnits            | No units defined for 1-D compartment                                                                 |       |       |       |       |       |       |       |       |
      | TwoDimensionalCompartmentUnits            | No units defined for 2-D compartment                                                                 |       |       |       |       |       |       |       |       |
      | ThreeDimensionalCompartmentUnits          | No units defined for 3-D Compartment object                                                          |       |       |       |       |       |       |       |       |
      | AllowedAttributesOnCompartment            | Invalid attribute found on Compartment object                                                        |       |       |       |       |       |       |       |       |
      | NoUnitsOnCompartment                      | No units defined for Compartment object                                                              |       |       |       |       |       |       |       |       |
      | InvalidSpeciesCompartmentRef              | Invalid value found for Species 'compartment' attribute                                              |       |       |       |       |       |       |       |       |
      | HasOnlySubsNoSpatialUnits                 | Attribute 'spatialSizeUnits' must not be set if 'hasOnlySubstanceUnits'='true'                       |       |       |       |       |       |       |       |       |
      | NoSpatialUnitsInZeroD                     | Attribute 'spatialSizeUnits' must not be set if the compartment is zero-dimensional                  |       |       |       |       |       |       |       |       |
      | NoConcentrationInZeroD                    | Attribute 'initialConcentration' must not be set if the compartment is zero-dimensional              |       |       |       |       |       |       |       |       |
      | SpatialUnitsInOneD                        | Invalid value for 'spatialSizeUnits' attribute of a one-dimensional compartment                      |       |       |       |       |       |       |       |       |
      | SpatialUnitsInTwoD                        | Invalid value for the 'spatialSizeUnits' attribute of a two-dimensional compartment                  |       |       |       |       |       |       |       |       |
      | SpatialUnitsInThreeD                      | Invalid value for the 'spatialSizeUnits' attribute of a three-dimensional compartment                |       |       |       |       |       |       |       |       |
      | InvalidSpeciesSusbstanceUnits             | Invalid value for a Species 'units' attribute                                                        |       |       |       |       |       |       |       |       |
      | BothAmountAndConcentrationSet             | Cannot set both 'initialConcentration' and 'initialAmount' attributes simultaneously                 |       |       |       |       |       |       |       |       |
      | NonBoundarySpeciesAssignedAndUsed         | Cannot use a non-boundary species in both reactions and rules simultaneously                         |       |       |       |       |       |       |       |       |
      | NonConstantSpeciesUsed                    | Cannot use a constant, non-boundary species as a reactant or product                                 |       |       |       |       |       |       |       |       |
      | InvalidSpeciesTypeRef                     | Invalid value for the 'speciesType' attribute of a species                                           |       |       |       |       |       |       |       |       |
      | MultSpeciesSameTypeInCompartment          | Cannot have multiple species of the same species type in the same compartment                        |       |       |       |       |       |       |       |       |
      | MissingSpeciesCompartment                 | Missing value for the 'compartment' attribute                                                        |       |       |       |       |       |       |       |       |
      | SpatialSizeUnitsRemoved                   | Attribute 'spatialSizeUnits' is not supported in this Level+Version of SBML                          |       |       |       |       |       |       |       |       |
      | SubstanceUnitsOnSpecies                   | No substance units defined for the species                                                           |       |       |       |       |       |       |       |       |
      | ConversionFactorOnSpecies                 | Invalid value for the 'conversionFactor' attribute                                                   |       |       |       |       |       |       |       |       |
      | AllowedAttributesOnSpecies                | Invalid attribute found on Species object                                                            |       |       |       |       |       |       |       |       |
      | InvalidParameterUnits                     | Invalid value for the 'units' attribute of a Parameter object                                        |       |       |       |       |       |       |       |       |
      | ParameterUnits                            | No units defined for the parameter                                                                   |       |       |       |       |       |       |       |       |
      | ConversionFactorMustConstant              | A conversion factor must reference a Parameter object declared to be a constant                      |       |       |       |       |       |       |       |       |
      | AllowedAttributesOnParameter              | Invalid attribute found on Parameter object                                                          |       |       |       |       |       |       |       |       |
      | InvalidInitAssignSymbol                   | Invalid value for the 'symbol' attribute of an InitialAssignment object                              |       |       |       |       |       |       |       |       |
      | MultipleInitAssignments                   | Multiple initial assignments for the same 'symbol' value are not allowed                             |       |       |       |       |       |       |       |       |
      | InitAssignmentAndRuleForSameId            | Cannot set a value using both an initial assignment and an assignment rule simultaneously            |       |       |       |       |       |       |       |       |
      | OneMathElementPerInitialAssign            | An InitialAssignment object may contain one <math> element                                           |       |       |       |       |       |       |       |       |
      | AllowedAttributesOnInitialAssign          | Invalid attribute found on an InitialAssignment object                                               |       |       |       |       |       |       |       |       |
      | InitAssignmentCannotRef0DComp             | InitialAssignment cannot reference 0D compartment                                                    |       |       |       |       |       |       |       |       |
      | InvalidAssignRuleVariable                 | Invalid value for the 'variable' attribute of an AssignmentRule object                               |       |       |       |       |       |       |       |       |
      | InvalidRateRuleVariable                   | Invalid value for the 'variable' attribute of a RateRule object                                      |       |       |       |       |       |       |       |       |
      | AssignmentToConstantEntity                | An assignment rule cannot assign an entity declared to be constant                                   |       |       |       |       |       |       |       |       |
      | RateRuleForConstantEntity                 | A rate rule cannot assign an entity declared to be constant                                          |       |       |       |       |       |       |       |       |
      | CircularRuleDependency                    | Circular dependencies involving rules and reactions are not permitted                                |       |       |       |       |       |       |       |       |
      | OneMathElementPerRule                     | A rule object may contain one <math> element                                                         |       |       |       |       |       |       |       |       |
      | AllowedAttributesOnAssignRule             | Invalid attribute found on an AssignmentRule object                                                  |       |       |       |       |       |       |       |       |
      | AllowedAttributesOnRateRule               | Invalid attribute found on a RateRule object                                                         |       |       |       |       |       |       |       |       |
      | AllowedAttributesOnAlgRule                | Invalid attribute found on an AlgebraicRule object                                                   |       |       |       |       |       |       |       |       |
      | RuleCannotRef0DComp                       | Rule cannot reference 0D compartment                                                                 |       |       |       |       |       |       |       |       |
      | CircularDependencyRateOf                  | Circular dependencies are not permitted in RateRule and KineticLaw objects                           |       |       |       |       |       |       |       |       |
      | ConstraintMathNotBoolean                  | A Constraint object's <math> must evaluate to a Boolean value                                        |       |       |       |       |       |       |       |       |
      | IncorrectOrderInConstraint                | Subobjects inside the Constraint object are not in the prescribed order                              |       |       |       |       |       |       |       |       |
      | ConstraintNotInXHTMLNamespace             | A Constraint's Message subobject must be in the XHTML XML namespace                                  |       |       |       |       |       |       |       |       |
      | ConstraintContainsXMLDecl                 | XML declarations are not permitted within Constraint's Message objects                               |       |       |       |       |       |       |       |       |
      | ConstraintContainsDOCTYPE                 | XML DOCTYPE elements are not permitted within Constraint's Message objects                           |       |       |       |       |       |       |       |       |
      | InvalidConstraintContent                  | Invalid content for a Constraint object's Message object                                             |       |       |       |       |       |       |       |       |
      | OneMathElementPerConstraint               | A Constraint object may contain one <math> element                                                   |       |       |       |       |       |       |       |       |
      | OneMessageElementPerConstraint            | A Constraint object can only have one Message subobject                                              |       |       |       |       |       |       |       |       |
      | AllowedAttributesOnConstraint             | Invalid attribute found on Constraint object                                                         |       |       |       |       |       |       |       |       |
      | NoReactantsOrProducts                     | Cannot have a reaction with neither reactants nor products                                           |       |       |       |       |       |       |       |       |
      | IncorrectOrderInReaction                  | Subobjects inside the Reaction object are not in the prescribed order                                |       |       |       |       |       |       |       |       |
      | EmptyListInReaction                       | Reaction components, if present, cannot be empty                                                     |       |       |       |       |       |       |       |       |
      | InvalidReactantsProductsList              | Invalid object found in the list of reactants or products                                            |       |       |       |       |       |       |       |       |
      | InvalidModifiersList                      | Invalid object found in the list of modifiers                                                        |       |       |       |       |       |       |       |       |
      | OneSubElementPerReaction                  | A Reaction object can only contain one of each allowed type of object                                |       |       |       |       |       |       |       |       |
      | CompartmentOnReaction                     | Invalid value for the Reaction 'compartment' attribute                                               |       |       |       |       |       |       |       |       |
      | AllowedAttributesOnReaction               | Invalid attribute for a Reaction object                                                              |       |       |       |       |       |       |       |       |
      | InvalidSpeciesReference                   | Invalid 'species' attribute value in SpeciesReference object                                         |       |       |       |       |       |       |       |       |
      | BothStoichiometryAndMath                  | The 'stoichiometry' attribute and StoichiometryMath subobject are mutually exclusive                 |       |       |       |       |       |       |       |       |
      | AllowedAttributesOnSpeciesReference       | Invalid attribute found on the SpeciesReference object                                               |       |       |       |       |       |       |       |       |
      | AllowedAttributesOnModifier               | Invalid attribute found on the ModifierSpeciesReference object                                       |       |       |       |       |       |       |       |       |
      | UndeclaredSpeciesRef                      | Unknown species referenced in the kinetic law <math> formula                                         |       |       |       |       |       |       |       |       |
      | IncorrectOrderInKineticLaw                | Incorrect ordering of components in the KineticLaw object                                            |       |       |       |       |       |       |       |       |
      | EmptyListInKineticLaw                     | The list of parameters, if present, cannot be empty                                                  |       |       |       |       |       |       |       |       |
      | NonConstantLocalParameter                 | Parameters local to a KineticLaw object must have a 'constant' attribute value of 'true'             |       |       |       |       |       |       |       |       |
      | SubsUnitsNoLongerValid                    | Attribute 'substanceUnits' is not supported in this Level+Version of SBML                            |       |       |       |       |       |       |       |       |
      | TimeUnitsNoLongerValid                    | Attribute 'timeUnits' is not supported in this Level+Version of SBML                                 |       |       |       |       |       |       |       |       |
      | OneListOfPerKineticLaw                    | Only one ListOfLocalParameters object is permitted within a KineticLaw object                        |       |       |       |       |       |       |       |       |
      | OnlyLocalParamsInListOfLocalParams        | Only LocalParameter, Notes and Annotation objects are allowed in ListOfLocalParameter objects        |       |       |       |       |       |       |       |       |
      | AllowedAttributesOnListOfLocalParam       | Invalid attribute found on the ListOfLocalParameters object                                          |       |       |       |       |       |       |       |       |
      | OneMathPerKineticLaw                      | Only one <math> element is allowed in a KineticLaw object                                            |       |       |       |       |       |       |       |       |
      | UndeclaredSpeciesInStoichMath             | Unknown species referenced in the StoichiometryMath object's <math> formula                          |       |       |       |       |       |       |       |       |
      | AllowedAttributesOnKineticLaw             | Invalid attribute found on the KineticLaw object                                                     |       |       |       |       |       |       |       |       |
      | AllowedAttributesOnListOfSpeciesRef       | Invalid attribute found on the ListOfSpeciesReferences object                                        |       |       |       |       |       |       |       |       |
      | AllowedAttributesOnListOfMods             | Invalid attribute found on the ListOfModifiers object                                                |       |       |       |       |       |       |       |       |
      | L3V2FastDeprecated                        | Fast attribute deprecated                                                                            |       |       |       |       |       |       |       |       |
      | AllowedAttributesOnLocalParameter         | Invalid attribute found on the LocalParameter object                                                 |       |       |       |       |       |       |       |       |
      | LocalParameterShadowsSpecies              | Invalid attribute found on the LocalParameter object                                                 |       |       |       |       |       |       |       |       |
      | MissingTriggerInEvent                     | The Event object is missing a Trigger subobject                                                      |       |       |       |       |       |       |       |       |
      | TriggerMathNotBoolean                     | A Trigger object's <math> expression must evaluate to a Boolean value                                |       |       |       |       |       |       |       |       |
      | MissingEventAssignment                    | The Event object is missing an EventAssignment subobject                                             |       |       |       |       |       |       |       |       |
      | TimeUnitsEvent                            | Units referenced by 'timeUnits' attribute are not compatible with units of time                      |       |       |       |       |       |       |       |       |
      | IncorrectOrderInEvent                     | Incorrect ordering of components in Event object                                                     |       |       |       |       |       |       |       |       |
      | ValuesFromTriggerTimeNeedDelay            | Attribute 'useValuesFromTriggerTime'='false', but the Event object does not define a delay           |       |       |       |       |       |       |       |       |
      | DelayNeedsValuesFromTriggerTime           | The use of a Delay object requires the Event attribute 'useValuesFromTriggerTime'                    |       |       |       |       |       |       |       |       |
      | OneMathPerTrigger                         | A Trigger object may have one <math> element                                                         |       |       |       |       |       |       |       |       |
      | OneMathPerDelay                           | A Delay object may have one <math> element                                                           |       |       |       |       |       |       |       |       |
      | InvalidEventAssignmentVariable            | Invalid 'variable' attribute value in Event object                                                   |       |       |       |       |       |       |       |       |
      | EventAssignmentForConstantEntity          | An EventAssignment object cannot assign to a component having attribute 'constant'='true'            |       |       |       |       |       |       |       |       |
      | OneMathPerEventAssignment                 | An EventAssignment object may have one <math> element                                                |       |       |       |       |       |       |       |       |
      | AllowedAttributesOnEventAssignment        | Invalid attribute found on the EventAssignment object                                                |       |       |       |       |       |       |       |       |
      | OnlyOneDelayPerEvent                      | An Event object can only have one Delay subobject                                                    |       |       |       |       |       |       |       |       |
      | OneListOfEventAssignmentsPerEvent         | An Event object can only have one ListOfEventAssignments subobject                                   |       |       |       |       |       |       |       |       |
      | OnlyEventAssignInListOfEventAssign        | Only EventAssignment, Notes and Annotation objects are allowed in ListOfEventAssignments             |       |       |       |       |       |       |       |       |
      | AllowedAttributesOnListOfEventAssign      | Invalid attribute found on the ListOfEventAssignments object                                         |       |       |       |       |       |       |       |       |
      | AllowedAttributesOnEvent                  | Invalid attribute found on the Event object                                                          |       |       |       |       |       |       |       |       |
      | AllowedAttributesOnTrigger                | Invalid attribute found on the Trigger object                                                        |       |       |       |       |       |       |       |       |
      | AllowedAttributesOnDelay                  | Invalid attribute found on the Delay object                                                          |       |       |       |       |       |       |       |       |
      | PersistentNotBoolean                      | The Trigger attribute 'persistent' must evaluate to a Boolean value                                  |       |       |       |       |       |       |       |       |
      | InitialValueNotBoolean                    | The Trigger attribute 'initialValue' must evaluate to a Boolean value                                |       |       |       |       |       |       |       |       |
      | OnlyOnePriorityPerEvent                   | An Event object can only have one Priority subobject                                                 |       |       |       |       |       |       |       |       |
      | OneMathPerPriority                        | A Priority object may have one <math> element                                                        |       |       |       |       |       |       |       |       |
      | AllowedAttributesOnPriority               | Invalid attribute found on the Priority object                                                       |       |       |       |       |       |       |       |       |
      | CompartmentShouldHaveSize                 | It's best to define a size for every compartment in a model                                          |       |       |       |       |       |       |       |       |
      | SpeciesShouldHaveValue                    | It's best to define an initial amount or initial concentration for every species in a model          |       |       |       |       |       |       |       |       |
      | ParameterShouldHaveUnits                  | It's best to declare units for every parameter in a model                                            |       |       |       |       |       |       |       |       |
      | ParameterShouldHaveValue                  | It's best to declare values for every parameter in a model                                           |       |       |       |       |       |       |       |       |
      | LocalParameterShadowsId                   | Local parameters defined within a kinetic law shadow global object symbols                           |       |       |       |       |       |       |       |       |
      | CannotConvertToL1V1                       | Cannot convert to SBML Level 1 Version 1                                                             |       |       |       |       |       |       |       |       |
      | NoEventsInL1                              | SBML Level 1 does not support events                                                                 |       |       |       |       |       |       |       |       |
      | NoFunctionDefinitionsInL1                 | SBML Level 1 does not support function definitions                                                   |       |       |       |       |       |       |       |       |
      | NoConstraintsInL1                         | SBML Level 1 does not support constraints                                                            |       |       |       |       |       |       |       |       |
      | NoInitialAssignmentsInL1                  | SBML Level 1 does not support initial assignments                                                    |       |       |       |       |       |       |       |       |
      | NoSpeciesTypesInL1                        | SBML Level 1 does not support species types                                                          |       |       |       |       |       |       |       |       |
      | NoCompartmentTypeInL1                     | SBML Level 1 does not support compartment types                                                      |       |       |       |       |       |       |       |       |
      | NoNon3DCompartmentsInL1                   | SBML Level 1 only supports three-dimensional compartments                                            |       |       |       |       |       |       |       |       |
      | NoFancyStoichiometryMathInL1              | SBML Level 1 does not support non-integer nor non-rational stoichiometry formulas                    |       |       |       |       |       |       |       |       |
      | NoNonIntegerStoichiometryInL1             | SBML Level 1 does not support non-integer 'stoichiometry' attribute values                           |       |       |       |       |       |       |       |       |
      | NoUnitMultipliersOrOffsetsInL1            | SBML Level 1 does not support multipliers or offsets in unit definitions                             |       |       |       |       |       |       |       |       |
      | SpeciesCompartmentRequiredInL1            | In SBML Level 1, a value for 'compartment' is mandatory in species definitions                       |       |       |       |       |       |       |       |       |
      | NoSpeciesSpatialSizeUnitsInL1             | SBML Level 1 does not support species 'spatialSizeUnits' settings                                    |       |       |       |       |       |       |       |       |
      | NoSBOTermsInL1                            | SBML Level 1 does not support the 'sboTerm' attribute                                                |       |       |       |       |       |       |       |       |
      | StrictUnitsRequiredInL1                   | SBML Level 1 requires strict unit consistency                                                        |       |       |       |       |       |       |       |       |
      | ConversionFactorNotInL1                   | SBML Level 1 does not support the 'conversionFactor' attribute                                       |       |       |       |       |       |       |       |       |
      | CompartmentNotOnL1Reaction                | SBML Level 1 does not support the 'compartment' attribute on Reaction objects                        |       |       |       |       |       |       |       |       |
      | ExtentUnitsNotSubstance                   | Units of extent must be compatible with units of substance                                           |       |       |       |       |       |       |       |       |
      | GlobalUnitsNotDeclared                    | Global units must be refer to unit kind or unitDefinition                                            |       |       |       |       |       |       |       |       |
      | HasOnlySubstanceUnitsNotinL1              | The concept of hasOnlySubstanceUnits was not available in SBML Level 1                               |       |       |       |       |       |       |       |       |
      | AvogadroNotSupported                      | Avogadro not supported in Levels 2 and 1                                                             |       |       |       |       |       |       |       |       |
      | NoConstraintsInL2v1                       | SBML Level 2 Version 1 does not support Constraint objects                                           |       |       |       |       |       |       |       |       |
      | NoInitialAssignmentsInL2v1                | SBML Level 2 Version 1 does not support InitialAssignment objects                                    |       |       |       |       |       |       |       |       |
      | NoSpeciesTypeInL2v1                       | SBML Level 2 Version 1 does not support SpeciesType objects                                          |       |       |       |       |       |       |       |       |
      | NoCompartmentTypeInL2v1                   | SBML Level 2 Version 1 does not support CompartmentType objects                                      |       |       |       |       |       |       |       |       |
      | NoSBOTermsInL2v1                          | SBML Level 2 Version 1 does not support the 'sboTerm' attribute                                      |       |       |       |       |       |       |       |       |
      | NoIdOnSpeciesReferenceInL2v1              | SBML Level 2 Version 1 does not support the 'id' attribute on SpeciesReference objects               |       |       |       |       |       |       |       |       |
      | NoDelayedEventAssignmentInL2v1            | SBML Level 2 Version 1 does not support the 'useValuesFromTriggerTime' attribute                     |       |       |       |       |       |       |       |       |
      | StrictUnitsRequiredInL2v1                 | SBML Level 2 Version 1 requires strict unit consistency                                              |       |       |       |       |       |       |       |       |
      | IntegerSpatialDimensions                  | SBML Level 2 Version 1 requires that compartments have spatial dimensions of 0-3                     |       |       |       |       |       |       |       |       |
      | StoichiometryMathNotYetSupported          | Conversion to StoichiometryMath objects not yet supported                                            |       |       |       |       |       |       |       |       |
      | PriorityLostFromL3                        | SBML Level 2 Version 1 does not support priorities on Event objects                                  |       |       |       |       |       |       |       |       |
      | NonPersistentNotSupported                 | SBML Level 2 Version 1 does not support the 'persistent' attribute on Trigger objects                |       |       |       |       |       |       |       |       |
      | InitialValueFalseEventNotSupported        | SBML Level 2 Version 1 does not support the 'initialValue' attribute on Trigger objects              |       |       |       |       |       |       |       |       |
      | SBOTermNotUniversalInL2v2                 | The 'sboTerm' attribute is invalid for this component in SBML Level 2 Version 2                      |       |       |       |       |       |       |       |       |
      | NoUnitOffsetInL2v2                        | This Level+Version of SBML does not support the 'offset' attribute on Unit objects                   |       |       |       |       |       |       |       |       |
      | NoKineticLawTimeUnitsInL2v2               | This Level+Version of SBML does not support the 'timeUnits' attribute on KineticLaw objects          |       |       |       |       |       |       |       |       |
      | NoKineticLawSubstanceUnitsInL2v2          | This Level+Version of SBML does not support the 'substanceUnits' attribute on KineticLaw objects     |       |       |       |       |       |       |       |       |
      | NoDelayedEventAssignmentInL2v2            | This Level+Version of SBML does not support the 'useValuesFromTriggerTime' attribute                 |       |       |       |       |       |       |       |       |
      | ModelSBOBranchChangedBeyondL2v2           | The allowable 'sboTerm' attribute values for Model objects differ for this SBML Level+Version        |       |       |       |       |       |       |       |       |
      | StrictUnitsRequiredInL2v2                 | SBML Level 2 Version 2 requires strict unit consistency                                              |       |       |       |       |       |       |       |       |
      | StrictSBORequiredInL2v2                   | SBML Level 2 Version 2 requires strict SBO term consistency                                          |       |       |       |       |       |       |       |       |
      | DuplicateAnnotationInvalidInL2v2          | Duplicate top-level annotations are invalid in SBML Level 2 Version 2                                |       |       |       |       |       |       |       |       |
      | NoUnitOffsetInL2v3                        | This Level+Version of SBML does not support the 'offset' attribute on Unit objects                   |       |       |       |       |       |       |       |       |
      | NoKineticLawTimeUnitsInL2v3               | This Level+Version of SBML does not support the 'timeUnits' attribute on KineticLaw objects          |       |       |       |       |       |       |       |       |
      | NoKineticLawSubstanceUnitsInL2v3          | This Level+Version of SBML does not support the 'substanceUnits' attribute on KineticLaw objects     |       |       |       |       |       |       |       |       |
      | NoSpeciesSpatialSizeUnitsInL2v3           | This Level+Version of SBML does not support the 'spatialSizeUnit' attribute on Species objects       |       |       |       |       |       |       |       |       |
      | NoEventTimeUnitsInL2v3                    | This Level+Version of SBML does not support the 'timeUnits' attribute on Event objects               |       |       |       |       |       |       |       |       |
      | NoDelayedEventAssignmentInL2v3            | This Level+Version of SBML does not support the 'useValuesFromTriggerTime' attribute                 |       |       |       |       |       |       |       |       |
      | ModelSBOBranchChangedBeyondL2v3           | The allowable 'sboTerm' attribute values for Model objects differ for this SBML Level+Version        |       |       |       |       |       |       |       |       |
      | StrictUnitsRequiredInL2v3                 | SBML Level 2 Version 3 requires strict unit consistency                                              |       |       |       |       |       |       |       |       |
      | StrictSBORequiredInL2v3                   | SBML Level 2 Version 3 requires strict SBO term consistency                                          |       |       |       |       |       |       |       |       |
      | DuplicateAnnotationInvalidInL2v3          | Duplicate top-level annotations are invalid in SBML Level 2 Version 3                                |       |       |       |       |       |       |       |       |
      | NoUnitOffsetInL2v4                        | This Level+Version of SBML does not support the 'offset' attribute on Unit objects                   |       |       |       |       |       |       |       |       |
      | NoKineticLawTimeUnitsInL2v4               | This Level+Version of SBML does not support the 'timeUnits' attribute on KineticLaw objects          |       |       |       |       |       |       |       |       |
      | NoKineticLawSubstanceUnitsInL2v4          | This Level+Version of SBML does not support the 'substanceUnits' attribute on KineticLaw objects     |       |       |       |       |       |       |       |       |
      | NoSpeciesSpatialSizeUnitsInL2v4           | This Level+Version of SBML does not support the 'spatialSizeUnit' attribute on Species objects       |       |       |       |       |       |       |       |       |
      | NoEventTimeUnitsInL2v4                    | This Level+Version of SBML does not support the 'timeUnits' attribute on Event objects               |       |       |       |       |       |       |       |       |
      | ModelSBOBranchChangedInL2v4               | The allowable 'sboTerm' attribute values for Model objects differ for this SBML Level+Version        |       |       |       |       |       |       |       |       |
      | DuplicateAnnotationInvalidInL2v4          | Duplicate top-level annotations are invalid in SBML Level 2 Version 4                                |       |       |       |       |       |       |       |       |
      | NoSpeciesTypeInL3v1                       | SBML Level 3 Version 1 does not support SpeciesType objects                                          |       |       |       |       |       |       |       |       |
      | NoCompartmentTypeInL3v1                   | SBML Level 3 Version 1 does not support CompartmentType objects                                      |       |       |       |       |       |       |       |       |
      | NoUnitOffsetInL3v1                        | This Level+Version of SBML does not support the 'offset' attribute on Unit objects                   |       |       |       |       |       |       |       |       |
      | NoKineticLawTimeUnitsInL3v1               | This Level+Version of SBML does not support the 'timeUnits' attribute on KineticLaw objects          |       |       |       |       |       |       |       |       |
      | NoKineticLawSubstanceUnitsInL3v1          | This Level+Version of SBML does not support the 'substanceUnits' attribute on KineticLaw objects     |       |       |       |       |       |       |       |       |
      | NoSpeciesSpatialSizeUnitsInL3v1           | This Level+Version of SBML does not support the 'spatialSizeUnit' attribute on Species objects       |       |       |       |       |       |       |       |       |
      | NoEventTimeUnitsInL3v1                    | This Level+Version of SBML does not support the 'timeUnits' attribute on Event objects               |       |       |       |       |       |       |       |       |
      | ModelSBOBranchChangedInL3v1               | The allowable 'sboTerm' attribute values for Model objects differ for this SBML Level+Version        |       |       |       |       |       |       |       |       |
      | DuplicateAnnotationInvalidInL3v1          | Duplicate top-level annotations are invalid in SBML Level 3 Version 1                                |       |       |       |       |       |       |       |       |
      | NoCompartmentOutsideInL3v1                | This Level+Version of SBML does not support the 'outside' attribute on Compartment objects           |       |       |       |       |       |       |       |       |
      | NoStoichiometryMathInL3v1                 | This Level+Version of SBML does not support the StoichiometryMath object                             |       |       |       |       |       |       |       |       |
      | DoubleExponentNotSupported                | Exponent of type double not supported in Levels 2 and 1.                                             |       |       |       |       |       |       |       |       |
      | MathMLElementNotSupported                 | This MathML element is only permitted in L3V2                                                        |       |       |       |       |       |       |       |       |
      | EmptyListOfElementNotSupported            | Empty 'ListOf' element is only permitted in L3V2                                                     |       |       |       |       |       |       |       |       |
      | MissingMathElementNotSupported            | Missing <math> element is only permitted in L3V2                                                     |       |       |       |       |       |       |       |       |
      | MissingTriggerElementNotSupported         | missing <trigger> element is only permitted in L3V2                                                  |       |       |       |       |       |       |       |       |
      | BooleanNumericDiscrepancy                 | Interchange of Boolean and numeric values only permitted in L3V2                                     |       |       |       |       |       |       |       |       |
      | IdNameSBaseInL3V2                         | Conversion will lose attributes only available in L3V2 and higher                                    |       |       |       |       |       |       |       |       |
      | MissingParticipantsNotSupported           | Omission of both <listOfReactants> and <listOfProducts> is only valid in L3V2                        |       |       |       |       |       |       |       |       |
      | ConvertibleMathInitialAssignment          | Some L3V2-specific MathML elements are not permitted in InitialAssignment objects                    |       |       |       |       |       |       |       |       |
      | FastReactionsNotSupported                 | Conversion of reactions employing the 'fast' attribute is not supported                              |       |       |       |       |       |       |       |       |
      | InvalidSBMLLevelVersion                   | Unknown Level+Version combination of SBML                                                            |       |       |       |       |       |       |       |       |
      | AnnotationNotesNotAllowedLevel1           | Annotation objects on the SBML container element are not permitted in SBML Level 1                   |       |       |       |       |       |       |       |       |
      | InvalidRuleOrdering                       | Invalid ordering of rules                                                                            |       |       |       |       |       |       |       |       |
      | RequiredPackagePresent                    | The SBML document requires an SBML Level 3 package unavailable in this software                      |       |       |       |       |       |       |       |       |
      | UnrequiredPackagePresent                  | The SBML document uses an SBML Level 3 package unavailable in this software                          |       |       |       |       |       |       |       |       |
      | PackageRequiredShouldBeFalse              | This package expects required to be false                                                            |       |       |       |       |       |       |       |       |
      | SubsUnitsAllowedInKL                      | Disallowed value for attribute 'substanceUnits' on KineticLaw object                                 |       |       |       |       |       |       |       |       |
      | TimeUnitsAllowedInKL                      | Disallowed value for attribute 'timeUnits' on KineticLaw object                                      |       |       |       |       |       |       |       |       |
      | FormulaInLevel1KL                         | Only predefined functions are allowed in SBML Level 1 formulas                                       |       |       |       |       |       |       |       |       |
      | L3SubstanceUnitsOnModel                   | Invalid 'substanceUnits' attribute value                                                             |       |       |       |       |       |       |       |       |
      | StoichiometryMathMissingMath              | The <stoichiometryMath> element must contain a <math> element                                        |       |       |       |       |       |       |       |       |
      | TimeUnitsRemoved                          | This Level+Version of SBML does not support the 'timeUnits' attribute on Event objects               |       |       |       |       |       |       |       |       |
      | BadMathML                                 | Invalid MathML expression                                                                            |       |       |       |       |       |       |       |       |
      | FailedMathMLReadOfDouble                  | Missing or invalid floating-point number in MathML expression                                        |       |       |       |       |       |       |       |       |
      | FailedMathMLReadOfInteger                 | Missing or invalid integer in MathML expression                                                      |       |       |       |       |       |       |       |       |
      | FailedMathMLReadOfExponential             | Missing or invalid exponential expression in MathML                                                  |       |       |       |       |       |       |       |       |
      | FailedMathMLReadOfRational                | Missing or invalid rational expression in MathML                                                     |       |       |       |       |       |       |       |       |
      | BadMathMLNodeType                         | Invalid MathML element                                                                               |       |       |       |       |       |       |       |       |
      | InvalidMathMLAttribute                    | Invalid MathML attribute                                                                             |       |       |       |       |       |       |       |       |
      | NoTimeSymbolInFunctionDef                 | Use of <csymbol> for 'time' not allowed within FunctionDefinition objects                            |       |       |       |       |       |       |       |       |
      | NoBodyInFunctionDef                       | There must be a <lambda> body within the <math> element of a FunctionDefinition object               |       |       |       |       |       |       |       |       |
      | DanglingUnitSIdRef                        | Units must refer to valid unit or unitDefinition                                                     |       |       |       |       |       |       |       |       |
      | RDFMissingAboutTag                        | RDF missing the <about> tag                                                                          |       |       |       |       |       |       |       |       |
      | RDFEmptyAboutTag                          | RDF empty <about> tag                                                                                |       |       |       |       |       |       |       |       |
      | RDFAboutTagNotMetaid                      | RDF <about> tag is not metaid                                                                        |       |       |       |       |       |       |       |       |
      | RDFNotCompleteModelHistory                | RDF does not contain valid ModelHistory                                                              |       |       |       |       |       |       |       |       |
      | RDFNotModelHistory                        | RDF does not result in a ModelHistory                                                                |       |       |       |       |       |       |       |       |
      | AnnotationNotElement                      | Annotation must contain element                                                                      |       |       |       |       |       |       |       |       |
      | NestedAnnotationNotAllowed                | Nested annotations not allowed                                                                       |       |       |       |       |       |       |       |       |
      | UndeclaredUnits                           | Missing unit declarations on parameters or literal numbers in expression                             |       |       |       |       |       |       |       |       |
      | UndeclaredTimeUnitsL3                     | Unable to verify consistency of units: the unit of time has not been declared                        |       |       |       |       |       |       |       |       |
      | UndeclaredExtentUnitsL3                   | Unable to verify consistency of units: the units of reaction extent have not been declared           |       |       |       |       |       |       |       |       |
      | UndeclaredObjectUnitsL3                   | Unable to verify consistency of units: encountered a model entity with no declared units             |       |       |       |       |       |       |       |       |
      | CannotVerifyUnitsObjectNoMath             | Unable to verify consistency of units: encountered an object with no <math> element                  |       |       |       |       |       |       |       |       |
      | UnrecognisedSBOTerm                       | Unrecognized 'sboTerm' attribute value                                                               |       |       |       |       |       |       |       |       |
      | ObseleteSBOTerm                           | Obsolete 'sboTerm' attribute value                                                                   |       |       |       |       |       |       |       |       |
      | IncorrectCompartmentSpatialDimensions     | In SBML Level 1, only three-dimensional compartments are allowed                                     |       |       |       |       |       |       |       |       |
      | CompartmentTypeNotValidAttribute          | CompartmentType objects are not available in this Level+Version of SBML                              |       |       |       |       |       |       |       |       |
      | ConstantNotValidAttribute                 | This Level+Version of SBML does not support the 'constant' attribute on this component               |       |       |       |       |       |       |       |       |
      | MetaIdNotValidAttribute                   | Attribute 'metaid' is not available in SBML Level 1                                                  |       |       |       |       |       |       |       |       |
      | SBOTermNotValidAttributeBeforeL2V3        | The 'sboTerm' attribute is not available on this component before SBML Level 2 Version 3             |       |       |       |       |       |       |       |       |
      | InvalidL1CompartmentUnits                 | Invalid units for a compartment in SBML Level 1                                                      |       |       |       |       |       |       |       |       |
      | L1V1CompartmentVolumeReqd                 | In SBML Level 1, a compartment's volume must be specified                                            |       |       |       |       |       |       |       |       |
      | CompartmentTypeNotValidComponent          | CompartmentType objects are not available in this Level+Version of SBML                              |       |       |       |       |       |       |       |       |
      | ConstraintNotValidComponent               | Constraint objects are not available in this Level+Version of SBML                                   |       |       |       |       |       |       |       |       |
      | EventNotValidComponent                    | Event objects are not available in this Level+Version of SBML                                        |       |       |       |       |       |       |       |       |
      | SBOTermNotValidAttributeBeforeL2V2        | The 'sboTerm' attribute is invalid for this component before Level 2 Version 2                       |       |       |       |       |       |       |       |       |
      | FuncDefNotValidComponent                  | FunctionDefinition objects are not available in this Level+Version of SBML                           |       |       |       |       |       |       |       |       |
      | InitialAssignNotValidComponent            | InitialAssignment objects are not available in this Level+Version of SBML                            |       |       |       |       |       |       |       |       |
      | VariableNotValidAttribute                 | Attribute 'variable' is not available on this component in this Level+Version of SBML                |       |       |       |       |       |       |       |       |
      | UnitsNotValidAttribute                    | Attribute 'units' is not available on this component in this Level+Version of SBML                   |       |       |       |       |       |       |       |       |
      | ConstantSpeciesNotValidAttribute          | Attribute 'constant' is not available on Species objects in SBML Level 1                             |       |       |       |       |       |       |       |       |
      | SpatialSizeUnitsNotValidAttribute         | Attribute 'spatialSizeUnits' is not available on Species objects in SBML Level 1                     |       |       |       |       |       |       |       |       |
      | SpeciesTypeNotValidAttribute              | Attribute 'speciesType' is not available on Species objects in SBML Level 1                          |       |       |       |       |       |       |       |       |
      | HasOnlySubsUnitsNotValidAttribute         | Attribute 'hasOnlySubstanceUnits' is not available on Species objects in SBML Level 1                |       |       |       |       |       |       |       |       |
      | IdNotValidAttribute                       | Attribute 'id' is not available on SpeciesReference objects in SBML Level 1                          |       |       |       |       |       |       |       |       |
      | NameNotValidAttribute                     | Attribute 'name' is not available on SpeciesReference objects in SBML Level 1                        |       |       |       |       |       |       |       |       |
      | SpeciesTypeNotValidComponent              | The SpeciesType object is not supported in SBML Level 1                                              |       |       |       |       |       |       |       |       |
      | StoichiometryMathNotValidComponent        | The StoichiometryMath object is not supported in SBML Level 1                                        |       |       |       |       |       |       |       |       |
      | MultiplierNotValidAttribute               | Attribute 'multiplier' on Unit objects is not supported in SBML Level 1                              |       |       |       |       |       |       |       |       |
      | OffsetNotValidAttribute                   | Attribute 'offset' on Unit objects is only available in SBML Level 2 Version 1                       |       |       |       |       |       |       |       |       |
      | L3SpatialDimensionsUnset                  | No value given for 'spatialDimensions' attribute; assuming a value of 3                              |       |       |       |       |       |       |       |       |
      | PackageConversionNotSupported             | Conversion of SBML Level 3 package constructs is not yet supported                                   |       |       |       |       |       |       |       |       |
      | InvalidTargetLevelVersion                 | The requested SBML Level/Version combination is not known to exist                                   |       |       |       |       |       |       |       |       |
      | L3NotSupported                            | SBML Level 3 is not yet supported                                                                    |       |       |       |       |       |       |       |       |
      | CompUnknown                               |                                                                                                      |       |       |       |       |       |       |       |       |
      | CompNSUndeclared                          | The comp ns is not correctly declared                                                                |       |       |       |       |       |       |       |       |
      | CompElementNotInNs                        | Element not in comp namespace                                                                        |       |       |       |       |       |       |       |       |
      | CompDuplicateComponentId                  | Duplicate 'id' attribute value                                                                       |       |       |       |       |       |       |       |       |
      | CompUniqueModelIds                        | Model and ExternalModelDefinitions must have unique ids                                              |       |       |       |       |       |       |       |       |
      | CompUniquePortIds                         | Ports must have unique ids                                                                           |       |       |       |       |       |       |       |       |
      | CompInvalidSIdSyntax                      | Invalid SId syntax                                                                                   |       |       |       |       |       |       |       |       |
      | CompInvalidSubmodelRefSyntax              | Invalid submodelRef syntax                                                                           |       |       |       |       |       |       |       |       |
      | CompInvalidDeletionSyntax                 | Invalid deletion syntax                                                                              |       |       |       |       |       |       |       |       |
      | CompInvalidConversionFactorSyntax         | Invalid conversionFactor syntax                                                                      |       |       |       |       |       |       |       |       |
      | CompInvalidNameSyntax                     | Invalid name syntax                                                                                  |       |       |       |       |       |       |       |       |
      | CompReplacedUnitsShouldMatch              | Units of replaced elements should match replacement units.                                           |       |       |       |       |       |       |       |       |
      | CompOneListOfReplacedElements             | Only one <listOfReplacedElements> allowed.                                                           |       |       |       |       |       |       |       |       |
      | CompLOReplaceElementsAllowedElements      | Allowed children of <listOfReplacedElements>                                                         |       |       |       |       |       |       |       |       |
      | CompLOReplacedElementsAllowedAttribs      | Allowed <listOfReplacedElements> attributes                                                          |       |       |       |       |       |       |       |       |
      | CompEmptyLOReplacedElements               | <listOfReplacedElements> must not be empty                                                           |       |       |       |       |       |       |       |       |
      | CompOneReplacedByElement                  | Only one <replacedBy> object allowed.                                                                |       |       |       |       |       |       |       |       |
      | CompAttributeRequiredMissing              | Required comp:required attribute on <sbml>                                                           |       |       |       |       |       |       |       |       |
      | CompAttributeRequiredMustBeBoolean        | The comp:required attribute must be Boolean                                                          |       |       |       |       |       |       |       |       |
      | CompRequiredTrueIfElementsRemain          | The comp:required attribute must be 'true' if math changes                                           |       |       |       |       |       |       |       |       |
      | CompRequiredFalseIfAllElementsReplaced    | The comp:required attribute must be 'false' if math does not change                                  |       |       |       |       |       |       |       |       |
      | CompOneListOfModelDefinitions             | Only one <listOfModelDefinitions> allowed.                                                           |       |       |       |       |       |       |       |       |
      | CompEmptyLOModelDefs                      | <listOfModelDefinitions> and <listOfExternalModelDefinitions> must not be empty                      |       |       |       |       |       |       |       |       |
      | CompLOModelDefsAllowedElements            | Only <modelDefinitions> in <listOfModelDefinitions>                                                  |       |       |       |       |       |       |       |       |
      | CompLOExtModelDefsAllowedElements         | Only <externalModelDefinitions> in <listOfExternalModelDefinitions>                                  |       |       |       |       |       |       |       |       |
      | CompLOModelDefsAllowedAttributes          | Allowed <listOfModelDefinitions> attributes                                                          |       |       |       |       |       |       |       |       |
      | CompLOExtModDefsAllowedAttributes         | Allowed <listOfExternalModelDefinitions> attributes                                                  |       |       |       |       |       |       |       |       |
      | CompOneListOfExtModelDefinitions          | Only one <listOfExternalModelDefinitions> allowed.                                                   |       |       |       |       |       |       |       |       |
      | CompAttributeRequiredMustBeTrue           | The comp:required attribute must be 'true'                                                           |       |       |       |       |       |       |       |       |
      | CompExtModDefAllowedCoreAttributes        | Allowed <externalModelDefinitions> core attributes                                                   |       |       |       |       |       |       |       |       |
      | CompExtModDefAllowedElements              | Allowed <externalModelDefinitions> elements                                                          |       |       |       |       |       |       |       |       |
      | CompExtModDefAllowedAttributes            | Allowed <externalModelDefinitions> attributes                                                        |       |       |       |       |       |       |       |       |
      | CompReferenceMustBeL3                     | External models must be L3                                                                           |       |       |       |       |       |       |       |       |
      | CompModReferenceMustIdOfModel             | 'modelRef' must be the 'id' of a model in the 'source' document                                      |       |       |       |       |       |       |       |       |
      | CompExtModMd5DoesNotMatch                 | MD5 checksum does not match the 'source' document                                                    |       |       |       |       |       |       |       |       |
      | CompInvalidSourceSyntax                   | The 'comp:source' attribute must be of type 'anyURI'                                                 |       |       |       |       |       |       |       |       |
      | CompInvalidModelRefSyntax                 | The 'comp:modelRef' attribute must have the syntax of 'SId'                                          |       |       |       |       |       |       |       |       |
      | CompInvalidMD5Syntax                      | The 'comp:md5' attribute must have the syntax of 'string'                                            |       |       |       |       |       |       |       |       |
      | CompCircularExternalModelReference        | Circular reference in <externalModelDefinitiongt;                                                    |       |       |       |       |       |       |       |       |
      | CompOneListOfOnModel                      | Only one <listOfSubmodels> and one <listOfPorts> allowed                                             |       |       |       |       |       |       |       |       |
      | CompNoEmptyListOfOnModel                  | No empty listOf elements allowed                                                                     |       |       |       |       |       |       |       |       |
      | CompLOSubmodelsAllowedElements            | Allowed elements on <listOfSubmodels>                                                                |       |       |       |       |       |       |       |       |
      | CompLOPortsAllowedElements                | Allowed elements on <listOfPorts>                                                                    |       |       |       |       |       |       |       |       |
      | CompLOSubmodelsAllowedAttributes          | Allowed attributes on <listOfSubmodels>                                                              |       |       |       |       |       |       |       |       |
      | CompLOPortsAllowedAttributes              | Allowed attributes on <listOfPorts>                                                                  |       |       |       |       |       |       |       |       |
      | CompSubmodelAllowedCoreAttributes         | Allowed core attributes on <submodel>                                                                |       |       |       |       |       |       |       |       |
      | CompSubmodelAllowedElements               | Allowed elements on <submodel>                                                                       |       |       |       |       |       |       |       |       |
      | CompOneListOfDeletionOnSubmodel           | Only one <listOfDeletions> on a <submodel> allowed                                                   |       |       |       |       |       |       |       |       |
      | CompSubmodelNoEmptyLODeletions            | No empty listOfDeletions elements allowed                                                            |       |       |       |       |       |       |       |       |
      | CompLODeletionsAllowedElements            | Allowed elements on <listOfDeletions>                                                                |       |       |       |       |       |       |       |       |
      | CompLODeletionAllowedAttributes           | Allowed <listOfDeletions> attributes                                                                 |       |       |       |       |       |       |       |       |
      | CompSubmodelAllowedAttributes             | Allowed <submodel> attributes                                                                        |       |       |       |       |       |       |       |       |
      | CompModReferenceSyntax                    | 'comp:modelRef' must conform to SId syntax                                                           |       |       |       |       |       |       |       |       |
      | CompInvalidTimeConvFactorSyntax           | 'comp:timeConversionFactor' must conform to SId syntax                                               |       |       |       |       |       |       |       |       |
      | CompInvalidExtentConvFactorSyntax         | 'comp:extentConversionFactor' must conform to SId syntax                                             |       |       |       |       |       |       |       |       |
      | CompSubmodelMustReferenceModel            | The 'comp:modelRef' attribute must reference a model                                                 |       |       |       |       |       |       |       |       |
      | CompSubmodelCannotReferenceSelf           | The 'comp:modelRef' attribute cannot reference own model                                             |       |       |       |       |       |       |       |       |
      | CompModCannotCircularlyReferenceSelf      | <model> may not reference <submodel> that references itself.                                         |       |       |       |       |       |       |       |       |
      | CompTimeConversionMustBeParameter         | The 'comp:timeConversionFactor' must reference a parameter                                           |       |       |       |       |       |       |       |       |
      | CompExtentConversionMustBeParameter       | The 'comp:extentConversionFactor' must reference a parameter                                         |       |       |       |       |       |       |       |       |
      | CompPortRefMustReferencePort              | The 'comp:portRef' attribute must be the 'id' of a <port>                                            |       |       |       |       |       |       |       |       |
      | CompIdRefMustReferenceObject              | The 'comp:idRef' attribute must be the 'id' of a model element                                       |       |       |       |       |       |       |       |       |
      | CompUnitRefMustReferenceUnitDef           | The 'comp:unitRef' attribute must be the 'id' of a UnitDefinition                                    |       |       |       |       |       |       |       |       |
      | CompMetaIdRefMustReferenceObject          | The 'comp:metaIdRef' attribute must be the 'metaid' of an object                                     |       |       |       |       |       |       |       |       |
      | CompParentOfSBRefChildMustBeSubmodel      | If <sBaseRef> has a child <sBaseRef> its parent must be a <submodel>                                 |       |       |       |       |       |       |       |       |
      | CompInvalidPortRefSyntax                  | The 'comp:portRef' attribute must have the syntax of an SBML SId                                     |       |       |       |       |       |       |       |       |
      | CompInvalidIdRefSyntax                    | The 'comp:idRef' attribute must have the syntax of an SBML SId                                       |       |       |       |       |       |       |       |       |
      | CompInvalidUnitRefSyntax                  | The 'comp:unitRef' attribute must have the syntax of an SBML SId                                     |       |       |       |       |       |       |       |       |
      | CompInvalidMetaIdRefSyntax                | The 'comp:metaIdRef' attribute must have the syntax of an XML ID                                     |       |       |       |       |       |       |       |       |
      | CompOneSBaseRefOnly                       | Only one <sbaseRef>                                                                                  |       |       |       |       |       |       |       |       |
      | CompDeprecatedSBaseRefSpelling            | The spelling 'sbaseRef' is deprecated                                                                |       |       |       |       |       |       |       |       |
      | CompSBaseRefMustReferenceObject           | An SBaseRef must reference an object.                                                                |       |       |       |       |       |       |       |       |
      | CompSBaseRefMustReferenceOnlyOneObject    | An SBaseRef must reference only one other object.                                                    |       |       |       |       |       |       |       |       |
      | CompNoMultipleReferences                  | Objects may not be referenced by mutiple SBaseRef constructs.                                        |       |       |       |       |       |       |       |       |
      | CompPortMustReferenceObject               | Port must reference an object                                                                        |       |       |       |       |       |       |       |       |
      | CompPortMustReferenceOnlyOneObject        | Port must reference only one other object.                                                           |       |       |       |       |       |       |       |       |
      | CompPortAllowedAttributes                 | Allowed attributes on a Port                                                                         |       |       |       |       |       |       |       |       |
      | CompPortReferencesUnique                  | Port definitions must be unique.                                                                     |       |       |       |       |       |       |       |       |
      | CompDeletionMustReferenceObject           | Deletion must reference an object                                                                    |       |       |       |       |       |       |       |       |
      | CompDeletionMustReferOnlyOneObject        | Deletion must reference only one other object.                                                       |       |       |       |       |       |       |       |       |
      | CompDeletionAllowedAttributes             | Allowed attributes on a Deletion                                                                     |       |       |       |       |       |       |       |       |
      | CompReplacedElementMustRefObject          | ReplacedElement must reference an object                                                             |       |       |       |       |       |       |       |       |
      | CompReplacedElementMustRefOnlyOne         | ReplacedElement must reference only one other object.                                                |       |       |       |       |       |       |       |       |
      | CompReplacedElementAllowedAttributes      | Allowed attributes on <replacedElement>                                                              |       |       |       |       |       |       |       |       |
      | CompReplacedElementSubModelRef            | The 'comp:submodelRef' attribute must point to a <submodel>                                          |       |       |       |       |       |       |       |       |
      | CompReplacedElementDeletionRef            | The 'comp:deletion' attribute must point to a <deletion>                                             |       |       |       |       |       |       |       |       |
      | CompReplacedElementConvFactorRef          | The 'comp:conversionFactor attribute must point to a <parameter>                                     |       |       |       |       |       |       |       |       |
      | CompReplacedElementSameReference          | No <replacedElement> refer to same object                                                            |       |       |       |       |       |       |       |       |
      | CompReplacedElementNoDelAndConvFact       | No <replacedElement> with deletion and conversionfactor                                              |       |       |       |       |       |       |       |       |
      | CompReplacedByMustRefObject               | ReplacedBy must reference an object                                                                  |       |       |       |       |       |       |       |       |
      | CompReplacedByMustRefOnlyOne              | ReplacedBy must reference only one other object.                                                     |       |       |       |       |       |       |       |       |
      | CompReplacedByAllowedAttributes           | Allowed attributes on <replacedBy>                                                                   |       |       |       |       |       |       |       |       |
      | CompReplacedBySubModelRef                 | The 'comp:submodelRef' attribute must point to a <submodel>                                          |       |       |       |       |       |       |       |       |
      | CompMustReplaceSameClass                  | Replaced classes must match.                                                                         |       |       |       |       |       |       |       |       |
      | CompMustReplaceIDs                        | Replaced IDs must be replaced with IDs.                                                              |       |       |       |       |       |       |       |       |
      | CompMustReplaceMetaIDs                    | Replaced metaids must be replaced with metaids.                                                      |       |       |       |       |       |       |       |       |
      | CompMustReplacePackageIDs                 | Replaced package IDs must be replaced with package IDs.                                              |       |       |       |       |       |       |       |       |
      | CompUnresolvedReference                   | Unresolved reference.                                                                                |       |       |       |       |       |       |       |       |
      | CompNoModelInReference                    | No model in referenced document.                                                                     |       |       |       |       |       |       |       |       |
      | CompExtModDefBad                          | Referenced <externalModelDefinitiongt; unresolvable.                                                 |       |       |       |       |       |       |       |       |
      | CompModelFlatteningFailed                 | Model failed to flatten.                                                                             |       |       |       |       |       |       |       |       |
      | CompFlatModelNotValid                     | Flat model not valid.                                                                                |       |       |       |       |       |       |       |       |
      | CompLineNumbersUnreliable                 | Line numbers unreliable.                                                                             |       |       |       |       |       |       |       |       |
      | CompFlatteningNotRecognisedReqd           | Flattening not implemented for required package.                                                     |       |       |       |       |       |       |       |       |
      | CompFlatteningNotRecognisedNotReqd        | Flattening not implemented for unrequired package.                                                   |       |       |       |       |       |       |       |       |
      | CompFlatteningNotImplementedNotReqd       | Flattening not implemented for unrequired package.                                                   |       |       |       |       |       |       |       |       |
      | CompFlatteningNotImplementedReqd          | Flattening not implemented for required package.                                                     |       |       |       |       |       |       |       |       |
      | CompFlatteningWarning                     | Flattening reference may come from package.                                                          |       |       |       |       |       |       |       |       |
      | CompDeprecatedDeleteFunction              | The performDeletions functions is deprecated.                                                        |       |       |       |       |       |       |       |       |
      | CompDeprecatedReplaceFunction             | The performReplacementsAndConversions fuctions is deprecated.                                        |       |       |       |       |       |       |       |       |
      | CompDeletedReplacement                    | Element deleted before a subelement could be replaced.                                               |       |       |       |       |       |       |       |       |
      | CompIdRefMayReferenceUnknownPackage       | The 'comp:idRef' attribute must be the 'id' of a model element                                       |       |       |       |       |       |       |       |       |
      | CompMetaIdRefMayReferenceUnknownPkg       | The 'comp:metaIdRef' attribute must be the 'metaid' of a model element                               |       |       |       |       |       |       |       |       |
      | FbcUnknown                                |                                                                                                      |       |       |       |       |       |       |       |       |
      | FbcNSUndeclared                           | The fbc ns is not correctly declared                                                                 |       |       |       |       |       |       |       |       |
      | FbcElementNotInNs                         | Element not in fbc namespace                                                                         |       |       |       |       |       |       |       |       |
      | FbcDuplicateComponentId                   | Duplicate 'id' attribute value                                                                       |       |       |       |       |       |       |       |       |
      | FbcSBMLSIdSyntax                          | Invalid 'id' attribute                                                                               |       |       |       |       |       |       |       |       |
      | FbcAttributeRequiredMissing               | Required fbc:required attribute on <sbml>                                                            |       |       |       |       |       |       |       |       |
      | FbcAttributeRequiredMustBeBoolean         | The fbc:required attribute must be Boolean                                                           |       |       |       |       |       |       |       |       |
      | FbcRequiredFalse                          | The fbc:required attribute must be 'false'                                                           |       |       |       |       |       |       |       |       |
      | FbcOnlyOneEachListOf                      | One of each list of allowed                                                                          |       |       |       |       |       |       |       |       |
      | FbcNoEmptyListOfs                         | ListOf elements cannot be empty                                                                      |       |       |       |       |       |       |       |       |
      | FbcLOFluxBoundsAllowedElements            | Allowed elements on ListOfFluxBounds                                                                 |       |       |       |       |       |       |       |       |
      | FbcLOObjectivesAllowedElements            | Allowed elements on ListOfObjectives                                                                 |       |       |       |       |       |       |       |       |
      | FbcLOFluxBoundsAllowedAttributes          | Allowed attributes on ListOfFluxBounds                                                               |       |       |       |       |       |       |       |       |
      | FbcLOObjectivesAllowedAttributes          | Allowed attributes on ListOfObjectives                                                               |       |       |       |       |       |       |       |       |
      | FbcActiveObjectiveSyntax                  | Type of activeObjective attribute                                                                    |       |       |       |       |       |       |       |       |
      | FbcActiveObjectiveRefersObjective         | ActiveObjective must reference Objective                                                             |       |       |       |       |       |       |       |       |
      | FbcModelMustHaveStrict                    | 'Strict' attribute required on <model>                                                               |       |       |       |       |       |       |       |       |
      | FbcModelStrictMustBeBoolean               | 'Strict' attribute must be Boolean                                                                   |       |       |       |       |       |       |       |       |
      | FbcLOGeneProductsAllowedElements          | Allowed elements on ListOfGeneProducts                                                               |       |       |       |       |       |       |       |       |
      | FbcLOGeneProductsAllowedAttributes        | Allowed attributes on ListOfGeneProducts                                                             |       |       |       |       |       |       |       |       |
      | FbcSpeciesAllowedL3Attributes             | Species allowed attributes                                                                           |       |       |       |       |       |       |       |       |
      | FbcSpeciesChargeMustBeInteger             | Charge must be integer                                                                               |       |       |       |       |       |       |       |       |
      | FbcSpeciesFormulaMustBeString             | Chemical formula must be string                                                                      |       |       |       |       |       |       |       |       |
      | FbcFluxBoundAllowedL3Attributes           | <fluxBound> may only have 'metaId' and 'sboTerm' from L3 namespace                                   |       |       |       |       |       |       |       |       |
      | FbcFluxBoundAllowedElements               | <fluxBound> may only have <notes> and <annotations> from L3 Core                                     |       |       |       |       |       |       |       |       |
      | FbcFluxBoundRequiredAttributes            | Invalid attribute found on <fluxBound> object                                                        |       |       |       |       |       |       |       |       |
      | FbcFluxBoundRectionMustBeSIdRef           | Datatype for 'fbc:reaction' must be SIdRef                                                           |       |       |       |       |       |       |       |       |
      | FbcFluxBoundNameMustBeString              | The attribute 'fbc:name' must be of the data type string                                             |       |       |       |       |       |       |       |       |
      | FbcFluxBoundOperationMustBeEnum           | The attribute 'fbc:operation' must be of data type FbcOperation                                      |       |       |       |       |       |       |       |       |
      | FbcFluxBoundValueMustBeDouble             | The attribute 'fbc:value' must be of the data type double                                            |       |       |       |       |       |       |       |       |
      | FbcFluxBoundReactionMustExist             | 'fbc:reaction' must refer to valid reaction                                                          |       |       |       |       |       |       |       |       |
      | FbcFluxBoundsForReactionConflict          | Conflicting set of FluxBounds for a reaction                                                         |       |       |       |       |       |       |       |       |
      | FbcObjectiveAllowedL3Attributes           | <objective> may only have 'metaId' and 'sboTerm' from L3 namespace                                   |       |       |       |       |       |       |       |       |
      | FbcObjectiveAllowedElements               | <objective> may only have <notes> and <annotations> from L3 Core                                     |       |       |       |       |       |       |       |       |
      | FbcObjectiveRequiredAttributes            | Invalid attribute found on <objective> object                                                        |       |       |       |       |       |       |       |       |
      | FbcObjectiveNameMustBeString              | The attribute 'fbc:name' must be of the data type string                                             |       |       |       |       |       |       |       |       |
      | FbcObjectiveTypeMustBeEnum                | The attribute 'fbc:type' must be of data type FbcType.                                               |       |       |       |       |       |       |       |       |
      | FbcObjectiveOneListOfObjectives           | An <objective> must have one <listOfFluxObjectives>.                                                 |       |       |       |       |       |       |       |       |
      | FbcObjectiveLOFluxObjMustNotBeEmpty       | <listOfFluxObjectives> subobject must not be empty                                                   |       |       |       |       |       |       |       |       |
      | FbcObjectiveLOFluxObjOnlyFluxObj          | Invalid element found in <listOfFluxObjectives>                                                      |       |       |       |       |       |       |       |       |
      | FbcObjectiveLOFluxObjAllowedAttribs       | <listOfFluxObjectives> may only have 'metaId' and 'sboTerm' from L3 core                             |       |       |       |       |       |       |       |       |
      | FbcFluxObjectAllowedL3Attributes          | <fluxObjectivegt; may only have 'metaId' and 'sboTerm' from L3 namespace                             |       |       |       |       |       |       |       |       |
      | FbcFluxObjectAllowedElements              | <fluxObjectivegt; may only have <notes> and <annotations> from L3 Core                               |       |       |       |       |       |       |       |       |
      | FbcFluxObjectRequiredAttributes           | Invalid attribute found on <fluxObjectivegt; object                                                  |       |       |       |       |       |       |       |       |
      | FbcFluxObjectNameMustBeString             | The attribute 'fbc:name' must be of the data type string                                             |       |       |       |       |       |       |       |       |
      | FbcFluxObjectReactionMustBeSIdRef         | Datatype for 'fbc:reaction' must be SIdRef                                                           |       |       |       |       |       |       |       |       |
      | FbcFluxObjectReactionMustExist            | 'fbc:reaction' must refer to valid reaction                                                          |       |       |       |       |       |       |       |       |
      | FbcFluxObjectCoefficientMustBeDouble      | The attribute 'fbc:coefficient' must be of the data type double                                      |       |       |       |       |       |       |       |       |
      | FbcFluxObjectCoefficientWhenStrict        | The 'fbc:coefficient' must be declared when strict                                                   |       |       |       |       |       |       |       |       |
      | FbcReactionOnlyOneGeneProdAss             | One GeneProductAssociation in a Reaction                                                             |       |       |       |       |       |       |       |       |
      | FbcReactionAllowedAttributes              | Fbc attributes on a Reaction                                                                         |       |       |       |       |       |       |       |       |
      | FbcReactionLwrBoundSIdRef                 | LowerBound must be SIdRef                                                                            |       |       |       |       |       |       |       |       |
      | FbcReactionUpBoundSIdRef                  | UpperBound must be SIdRef                                                                            |       |       |       |       |       |       |       |       |
      | FbcReactionLwrBoundRefExists              | LowerBound must point to Parameter                                                                   |       |       |       |       |       |       |       |       |
      | FbcReactionUpBoundRefExists               | UpperBound must point to Parameter                                                                   |       |       |       |       |       |       |       |       |
      | FbcReactionMustHaveBoundsStrict           | Reaction must have bounds when strict                                                                |       |       |       |       |       |       |       |       |
      | FbcReactionConstantBoundsStrict           | Reaction bounds constant when strict                                                                 |       |       |       |       |       |       |       |       |
      | FbcReactionBoundsMustHaveValuesStrict     | Reaction bounds must have values when strict                                                         |       |       |       |       |       |       |       |       |
      | FbcReactionBoundsNotAssignedStrict        | Reaction bounds not assigned when strict                                                             |       |       |       |       |       |       |       |       |
      | FbcReactionLwrBoundNotInfStrict           | LowerBound cannot be INF when strict                                                                 |       |       |       |       |       |       |       |       |
      | FbcReactionUpBoundNotNegInfStrict         | UpperBound cannot be -INF when strict                                                                |       |       |       |       |       |       |       |       |
      | FbcReactionLwrLessThanUpStrict            | LowerBound less than upperBound when strict                                                          |       |       |       |       |       |       |       |       |
      | FbcSpeciesReferenceConstantStrict         | SpeciesReferences must be constant when strict                                                       |       |       |       |       |       |       |       |       |
      | FbcSpeciesRefsStoichMustBeRealStrict      | Stoichiometry of SpeciesReferences must be real valued when strict                                   |       |       |       |       |       |       |       |       |
      | FbcSpeciesRefNotAssignedStrict            | SpeciesReference not target of InitialAssignment when strict                                         |       |       |       |       |       |       |       |       |
      | FbcGeneProdAssocAllowedCoreAttribs        | Allowed core attributes on <GeneProductAssociationgt;                                                |       |       |       |       |       |       |       |       |
      | FbcGeneProdAssocAllowedCoreElements       | Allowed core elements on <GeneProductAssociationgt;                                                  |       |       |       |       |       |       |       |       |
      | FbcGeneProdAssocAllowedAttribs            | Allowed fbc attributes on <GeneProductAssociationgt;                                                 |       |       |       |       |       |       |       |       |
      | FbcGeneProdAssocIdSyntax                  | 'fbc:id' must have SId syntax                                                                        |       |       |       |       |       |       |       |       |
      | FbcGeneProdAssocContainsOneElement        | <GeneProductAssociationgt; must contain one concrete object                                          |       |       |       |       |       |       |       |       |
      | FbcGeneProdAssocNameMustBeString          | 'fbc:name' must be string                                                                            |       |       |       |       |       |       |       |       |
      | FbcGeneProdRefAllowedCoreAttribs          | Allowed core attributes on <GeneProductRefgt;                                                        |       |       |       |       |       |       |       |       |
      | FbcGeneProdRefAllowedCoreElements         | Allowed core elements on <GeneProductRefgt;                                                          |       |       |       |       |       |       |       |       |
      | FbcGeneProdRefAllowedAttribs              | Allowed fbc attributes on <GeneProductRefgt;                                                         |       |       |       |       |       |       |       |       |
      | FbcGeneProdRefGeneProductSIdRef           | 'fbc:geneProduct' must be SIdRef                                                                     |       |       |       |       |       |       |       |       |
      | FbcGeneProdRefGeneProductExists           | 'fbc:geneProduct' must point to existing <GeneProductgt;                                             |       |       |       |       |       |       |       |       |
      | FbcAndAllowedCoreAttributes               | Allowed core attributes on <And>                                                                     |       |       |       |       |       |       |       |       |
      | FbcAndAllowedCoreElements                 | Allowed core attributes on <And>                                                                     |       |       |       |       |       |       |       |       |
      | FbcAndTwoChildren                         | <And> must have at least two child elements                                                          |       |       |       |       |       |       |       |       |
      | FbcOrAllowedCoreAttributes                | Allowed core attributes on <Or>                                                                      |       |       |       |       |       |       |       |       |
      | FbcOrAllowedCoreElements                  | Allowed core elements on <Or>                                                                        |       |       |       |       |       |       |       |       |
      | FbcOrTwoChildren                          | <Or> must have at least two child elements                                                           |       |       |       |       |       |       |       |       |
      | FbcGeneProductAllowedCoreAttributes       | Allowed core attributes on <GeneProductgt;                                                           |       |       |       |       |       |       |       |       |
      | FbcGeneProductAllowedCoreElements         | Allowed core elements on <GeneProductgt;                                                             |       |       |       |       |       |       |       |       |
      | FbcGeneProductAllowedAttributes           | Allowed fbc attributes on <GeneProductgt;                                                            |       |       |       |       |       |       |       |       |
      | FbcGeneProductLabelMustBeString           | 'fbc:label' must be string                                                                           |       |       |       |       |       |       |       |       |
      | FbcGeneProductLabelMustBeUnique           | 'fbc:label' must be unique                                                                           |       |       |       |       |       |       |       |       |
      | FbcGeneProductNameMustBeString            | 'fbc:name' must be string                                                                            |       |       |       |       |       |       |       |       |
      | FbcGeneProductAssocSpeciesMustExist       | 'fbc:associatedSpecies' must point to existing <species>                                             |       |       |       |       |       |       |       |       |
      | QualUnknown                               |                                                                                                      |       |       |       |       |       |       |       |       |
      | QualNSUndeclared                          | The qual ns is not correctly declared                                                                |       |       |       |       |       |       |       |       |
      | QualElementNotInNs                        | Element not in qual namespace                                                                        |       |       |       |       |       |       |       |       |
      | QualFunctionTermBool                      | FunctionTerm should return Boolean                                                                   |       |       |       |       |       |       |       |       |
      | QualMathCSymbolDisallowed                 | CSymbol time or delay not allowed                                                                    |       |       |       |       |       |       |       |       |
      | QualDuplicateComponentId                  | Duplicate 'id' attribute value                                                                       |       |       |       |       |       |       |       |       |
      | QualAttributeRequiredMissing              | Required qual:required attribute on <sbml>                                                           |       |       |       |       |       |       |       |       |
      | QualAttributeRequiredMustBeBoolean        | The qual:required attribute must be Boolean                                                          |       |       |       |       |       |       |       |       |
      | QualRequiredTrueIfTransitions             | The qual:required attribute must be 'true' if math changes                                           |       |       |       |       |       |       |       |       |
      | QualOneListOfTransOrQS                    | Only one <listOfTransitions> or <listOfQualitativeSpeciesgt; allowed.                                |       |       |       |       |       |       |       |       |
      | QualEmptyLONotAllowed                     | Empty <listOfTransitions> or <listOfQualitativeSpeciesgt; not allowed.                               |       |       |       |       |       |       |       |       |
      | QualLOTransitiondAllowedElements          | Elements allowed on <listOfTransitions>.                                                             |       |       |       |       |       |       |       |       |
      | QualLOQualSpeciesAllowedElements          | Elements allowed on <listOfTransitions>.                                                             |       |       |       |       |       |       |       |       |
      | QualLOQualSpeciesAllowedAttributes        | Attributes allowed on <listOfQualitativeSpeciesgt;.                                                  |       |       |       |       |       |       |       |       |
      | QualLOTransitionsAllowedAttributes        | Attributes allowed on <listOfTransitions>.                                                           |       |       |       |       |       |       |       |       |
      | QualQualSpeciesAllowedCoreAttributes      | Core attributes allowed on <qualitativeSpeciesgt;.                                                   |       |       |       |       |       |       |       |       |
      | QualQualSpeciesAllowedElements            | Elements allowed on <qualitativeSpeciesgt;.                                                          |       |       |       |       |       |       |       |       |
      | QualQualSpeciesAllowedAttributes          | Attributes allowed on <qualitativeSpeciesgt;.                                                        |       |       |       |       |       |       |       |       |
      | QualConstantMustBeBool                    | Attribute 'constant' on <qualitativeSpeciesgt; must be Boolean.                                      |       |       |       |       |       |       |       |       |
      | QualNameMustBeString                      | Attribute 'name' on <qualitativeSpeciesgt; must be string.                                           |       |       |       |       |       |       |       |       |
      | QualInitialLevelMustBeInt                 | Attribute 'initialLevel' on <qualitativeSpeciesgt; must be integer.                                  |       |       |       |       |       |       |       |       |
      | QualMaxLevelMustBeInt                     | Attribute 'maxLevel' on <qualitativeSpeciesgt; must be integer.                                      |       |       |       |       |       |       |       |       |
      | QualCompartmentMustReferExisting          | Attribute 'compartment' on <qualitativeSpeciesgt; must reference compartment.                        |       |       |       |       |       |       |       |       |
      | QualInitialLevelCannotExceedMax           | Attribute 'initialLevel' on <qualitativeSpeciesgt; cannot exceed maxLevel.                           |       |       |       |       |       |       |       |       |
      | QualConstantQSCannotBeOutput              | Constant <qualitativeSpeciesgt; cannot be an Output.                                                 |       |       |       |       |       |       |       |       |
      | QualQSAssignedOnlyOnce                    | A <qualitativeSpeciesgt; can only be assigned once.                                                  |       |       |       |       |       |       |       |       |
      | QualInitalLevelNotNegative                | Attribute 'initialLevel' on <qualitativeSpeciesgt; cannot be negative.                               |       |       |       |       |       |       |       |       |
      | QualMaxLevelNotNegative                   | Attribute 'maxLevel' on <qualitativeSpeciesgt; cannot be negative.                                   |       |       |       |       |       |       |       |       |
      | QualTransitionAllowedCoreAttributes       | Core attributes allowed on <transition>.                                                             |       |       |       |       |       |       |       |       |
      | QualTransitionAllowedElements             | Elements allowed on <transition>.                                                                    |       |       |       |       |       |       |       |       |
      | QualTransitionAllowedAttributes           | Attributes allowed on <transition>.                                                                  |       |       |       |       |       |       |       |       |
      | QualTransitionNameMustBeString            | Attribute 'name' on <transition> must be string.                                                     |       |       |       |       |       |       |       |       |
      | QualTransitionLOElements                  | ListOf elements on <transition>.                                                                     |       |       |       |       |       |       |       |       |
      | QualTransitionEmptyLOElements             | ListOf elements on <transition> not empty.                                                           |       |       |       |       |       |       |       |       |
      | QualTransitionLOInputElements             | Elements on <listOfInputs>.                                                                          |       |       |       |       |       |       |       |       |
      | QualTransitionLOOutputElements            | Elements on <listOfOutputs>.                                                                         |       |       |       |       |       |       |       |       |
      | QualTransitionLOFuncTermElements          | Elements on <listOfFunctionTerms>.                                                                   |       |       |       |       |       |       |       |       |
      | QualTransitionLOInputAttributes           | Attributes allowed on <listOfInputs>.                                                                |       |       |       |       |       |       |       |       |
      | QualTransitionLOOutputAttributes          | Attributes allowed on <listOfOutputs>.                                                               |       |       |       |       |       |       |       |       |
      | QualTransitionLOFuncTermAttributes        | Attributes allowed on <listOfFunctionTerms>.                                                         |       |       |       |       |       |       |       |       |
      | QualTransitionLOFuncTermExceedMax         | <listOfFunctionTerms> cannot make qualitativeSpecies exceed maxLevel.                                |       |       |       |       |       |       |       |       |
      | QualTransitionLOFuncTermNegative          | <listOfFunctionTerms> cannot make qualitativeSpecies negative.                                       |       |       |       |       |       |       |       |       |
      | QualInputAllowedCoreAttributes            | Core attributes allowed on <input>.                                                                  |       |       |       |       |       |       |       |       |
      | QualInputAllowedElements                  | Elements allowed on <input>.                                                                         |       |       |       |       |       |       |       |       |
      | QualInputAllowedAttributes                | Attributes allowed on <input>.                                                                       |       |       |       |       |       |       |       |       |
      | QualInputNameMustBeString                 | Attribute 'name' on <input> must be string.                                                          |       |       |       |       |       |       |       |       |
      | QualInputSignMustBeSignEnum               | Attribute 'sign' on <input> must be enum.                                                            |       |       |       |       |       |       |       |       |
      | QualInputTransEffectMustBeInputEffect     | Attribute 'transitionEffect' on <input> must be enum.                                                |       |       |       |       |       |       |       |       |
      | QualInputThreshMustBeInteger              | Attribute 'thresholdLevel' on <input> must be non negative integer.                                  |       |       |       |       |       |       |       |       |
      | QualInputQSMustBeExistingQS               | Attribute 'qualitativeSpecies' on <input> must refer to existing                                     |       |       |       |       |       |       |       |       |
      | QualInputConstantCannotBeConsumed         | Constant <input> cannot be consumed.                                                                 |       |       |       |       |       |       |       |       |
      | QualInputThreshMustBeNonNegative          | Attribute 'thresholdLevel' on <input> must be non negative integer.                                  |       |       |       |       |       |       |       |       |
      | QualOutputAllowedCoreAttributes           | Core attributes allowed on <output>.                                                                 |       |       |       |       |       |       |       |       |
      | QualOutputAllowedElements                 | Elements allowed on <output>.                                                                        |       |       |       |       |       |       |       |       |
      | QualOutputAllowedAttributes               | Attributes allowed on <output>.                                                                      |       |       |       |       |       |       |       |       |
      | QualOutputNameMustBeString                | Attribute 'name' on <output> must be string.                                                         |       |       |       |       |       |       |       |       |
      | QualOutputTransEffectMustBeOutput         | Attribute 'transitionEffect' on <output> must be enum.                                               |       |       |       |       |       |       |       |       |
      | QualOutputLevelMustBeInteger              | Attribute 'outputLevel' on <output> must be non negative integer.                                    |       |       |       |       |       |       |       |       |
      | QualOutputQSMustBeExistingQS              | Attribute 'qualitativeSpecies' on <output> must refer to existing                                    |       |       |       |       |       |       |       |       |
      | QualOutputConstantMustBeFalse             | Constant 'qualitativeSpecies' cannot be <output>                                                     |       |       |       |       |       |       |       |       |
      | QualOutputProductionMustHaveLevel         | <output> being produced must have level                                                              |       |       |       |       |       |       |       |       |
      | QualOutputLevelMustBeNonNegative          | Attribute 'outputLevel' on <output> must be non negative integer.                                    |       |       |       |       |       |       |       |       |
      | QualDefaultTermAllowedCoreAttributes      | Core attributes allowed on <defaultTerm>.                                                            |       |       |       |       |       |       |       |       |
      | QualDefaultTermAllowedElements            | Elements allowed on <defaultTerm>.                                                                   |       |       |       |       |       |       |       |       |
      | QualDefaultTermAllowedAttributes          | Attributes allowed on <defaultTerm>.                                                                 |       |       |       |       |       |       |       |       |
      | QualDefaultTermResultMustBeInteger        | Attribute 'resultLevel' on <defaultTerm> must be non negative integer.                               |       |       |       |       |       |       |       |       |
      | QualDefaultTermResultMustBeNonNeg         | Attribute 'resultLevel' on <defaultTerm> must be non negative integer.                               |       |       |       |       |       |       |       |       |
      | QualFuncTermAllowedCoreAttributes         | Core attributes allowed on <functionTerm>.                                                           |       |       |       |       |       |       |       |       |
      | QualFuncTermAllowedElements               | Elements allowed on <functionTerm>.                                                                  |       |       |       |       |       |       |       |       |
      | QualFuncTermAllowedAttributes             | Attributes allowed on <functionTerm>.                                                                |       |       |       |       |       |       |       |       |
      | QualFuncTermOnlyOneMath                   | Only one <math> on <functionTerm>.                                                                   |       |       |       |       |       |       |       |       |
      | QualFuncTermResultMustBeInteger           | Attribute 'resultLevel' on <functionTerm> must be non negative integer.                              |       |       |       |       |       |       |       |       |
      | QualFuncTermResultMustBeNonNeg            | Attribute 'resultLevel' on <functionTerm> must be non negative integer.                              |       |       |       |       |       |       |       |       |
      | GroupsUnknown                             |                                                                                                      |       |       |       |       |       |       |       |       |
      | GroupsNSUndeclared                        | The Groups namespace is not correctly declared.                                                      |       |       |       |       |       |       |       |       |
      | GroupsElementNotInNs                      | Element not in Groups namespace                                                                      |       |       |       |       |       |       |       |       |
      | GroupsDuplicateComponentId                | Duplicate 'id' attribute value                                                                       |       |       |       |       |       |       |       |       |
      | GroupsIdSyntaxRule                        | Invalid SId syntax                                                                                   |       |       |       |       |       |       |       |       |
      | GroupsAttributeRequiredMissing            | Required groups:required attribute on <sbml>                                                         |       |       |       |       |       |       |       |       |
      | GroupsAttributeRequiredMustBeBoolean      | The groups:required attribute must be Boolean                                                        |       |       |       |       |       |       |       |       |
      | GroupsAttributeRequiredMustHaveValue      | The groups:required attribute must be 'false'                                                        |       |       |       |       |       |       |       |       |
      | GroupsModelAllowedElements                | Elements allowed on <model>.                                                                         |       |       |       |       |       |       |       |       |
      | GroupsModelEmptyLOElements                | No Empty ListOf elements allowed on <Modelgt;.                                                       |       |       |       |       |       |       |       |       |
      | GroupsModelLOGroupsAllowedCoreElements    | Core elements allowed on <model>.                                                                    |       |       |       |       |       |       |       |       |
      | GroupsModelLOGroupsAllowedCoreAttributes  | Core attributes allowed on <model>.                                                                  |       |       |       |       |       |       |       |       |
      | GroupsGroupAllowedCoreAttributes          | Core attributes allowed on <group>.                                                                  |       |       |       |       |       |       |       |       |
      | GroupsGroupAllowedCoreElements            | Core elements allowed on <group>.                                                                    |       |       |       |       |       |       |       |       |
      | GroupsGroupAllowedAttributes              | Attributes allowed on <group>.                                                                       |       |       |       |       |       |       |       |       |
      | GroupsGroupAllowedElements                | Elements allowed on <group>.                                                                         |       |       |       |       |       |       |       |       |
      | GroupsGroupKindMustBeGroupKindEnum        | Kind attribute must be GroupKind.                                                                    |       |       |       |       |       |       |       |       |
      | GroupsGroupNameMustBeString               | Name attribute must be String.                                                                       |       |       |       |       |       |       |       |       |
      | GroupsGroupEmptyLOElements                | No Empty ListOf elements allowed on <group>.                                                         |       |       |       |       |       |       |       |       |
      | GroupsGroupLOMembersAllowedCoreElements   | Core elements allowed on <listOfMembers>.                                                            |       |       |       |       |       |       |       |       |
      | GroupsGroupLOMembersAllowedCoreAttributes | Core attributes allowed on <listOfMembers>.                                                          |       |       |       |       |       |       |       |       |
      | GroupsGroupLOMembersAllowedAttributes     | Attributes allowed on <listOfMembers>.                                                               |       |       |       |       |       |       |       |       |
      | GroupsLOMembersNameMustBeString           | Name attribute must be String.                                                                       |       |       |       |       |       |       |       |       |
      | GroupsLOMembersConsistentReferences       | Consistent references by multiple <member> objects.                                                  |       |       |       |       |       |       |       |       |
      | GroupsNotCircularReferences               | Circular references by multiple <member> objects.                                                    |       |       |       |       |       |       |       |       |
      | GroupsMemberAllowedCoreAttributes         | Core attributes allowed on <member>.                                                                 |       |       |       |       |       |       |       |       |
      | GroupsMemberAllowedCoreElements           | Core elements allowed on <member>.                                                                   |       |       |       |       |       |       |       |       |
      | GroupsMemberAllowedAttributes             | Attributes allowed on <member>.                                                                      |       |       |       |       |       |       |       |       |
      | GroupsMemberNameMustBeString              | Name attribute must be String.                                                                       |       |       |       |       |       |       |       |       |
      | GroupsMemberIdRefMustBeSBase              | Attribute 'idRef' must point to SBase object.                                                        |       |       |       |       |       |       |       |       |
      | GroupsMemberMetaIdRefMustBeSBase          | Attribute 'metaIdRef' must point to SBase object.                                                    |       |       |       |       |       |       |       |       |
      | GroupsMemberIdRefMustBeSId                | Attribute 'idRef' must be type 'SId'.                                                                |       |       |       |       |       |       |       |       |
      | GroupsMemberMetaIdRefMustBeID             | Attribute 'metaIdRef' must be type 'ID'.                                                             |       |       |       |       |       |       |       |       |
      | LayoutUnknownError                        |                                                                                                      |       |       |       |       |       |       |       |       |
      | LayoutNSUndeclared                        | The layout ns is not correctly declared                                                              |       |       |       |       |       |       |       |       |
      | LayoutElementNotInNs                      | Element not in layout namespace                                                                      |       |       |       |       |       |       |       |       |
      | LayoutDuplicateComponentId                | Duplicate 'id' attribute value                                                                       |       |       |       |       |       |       |       |       |
      | LayoutSIdSyntax                           | 'id' attribute incorrect syntax                                                                      |       |       |       |       |       |       |       |       |
      | LayoutXsiTypeAllowedLocations             | 'xsi:type' allowed locations                                                                         |       |       |       |       |       |       |       |       |
      | LayoutXsiTypeSyntax                       | 'xsi:type' attribute incorrect syntax                                                                |       |       |       |       |       |       |       |       |
      | LayoutAttributeRequiredMissing            | Required layout:required attribute on <sbml>                                                         |       |       |       |       |       |       |       |       |
      | LayoutAttributeRequiredMustBeBoolean      | The layout:required attribute must be Boolean                                                        |       |       |       |       |       |       |       |       |
      | LayoutRequiredFalse                       | The layout:required attribute must be 'false'                                                        |       |       |       |       |       |       |       |       |
      | LayoutOnlyOneLOLayouts                    | Only one listOfLayouts on <model>                                                                    |       |       |       |       |       |       |       |       |
      | LayoutLOLayoutsNotEmpty                   | ListOf elements cannot be empty                                                                      |       |       |       |       |       |       |       |       |
      | LayoutLOLayoutsAllowedElements            | Allowed elements on ListOfLayouts                                                                    |       |       |       |       |       |       |       |       |
      | LayoutLOLayoutsAllowedAttributes          | Allowed attributes on ListOfLayouts                                                                  |       |       |       |       |       |       |       |       |
      | LayoutLayoutAllowedElements               | Allowed elements on Layout                                                                           |       |       |       |       |       |       |       |       |
      | LayoutLayoutAllowedCoreAttributes         | Allowed core attributes on Layout                                                                    |       |       |       |       |       |       |       |       |
      | LayoutOnlyOneEachListOf                   | Only one each listOf on <layout>                                                                     |       |       |       |       |       |       |       |       |
      | LayoutNoEmptyListOfs                      | ListOf elements cannot be empty                                                                      |       |       |       |       |       |       |       |       |
      | LayoutLayoutAllowedAttributes             | <layout> must have 'id' and may have 'name'                                                          |       |       |       |       |       |       |       |       |
      | LayoutLayoutNameMustBeString              | 'name' must be string                                                                                |       |       |       |       |       |       |       |       |
      | LayoutLOCompGlyphAllowedAttributes        | Attributes allowed on <listOfCompartmentGlyphs>.                                                     |       |       |       |       |       |       |       |       |
      | LayoutLOCompGlyphAllowedElements          | Elements allowed on <listOfCompartmentGlyphs>.                                                       |       |       |       |       |       |       |       |       |
      | LayoutLOSpeciesGlyphAllowedAttributes     | Attributes allowed on <listOfSpeciesGlyphs>.                                                         |       |       |       |       |       |       |       |       |
      | LayoutLOSpeciesGlyphAllowedElements       | Elements allowed on <listOfSpeciesGlyphs>.                                                           |       |       |       |       |       |       |       |       |
      | LayoutLORnGlyphAllowedAttributes          | Attributes allowed on <listOfReactionGlyphs>.                                                        |       |       |       |       |       |       |       |       |
      | LayoutLORnGlyphAllowedElements            | Elements allowed on <listOfReactionGlyphs>.                                                          |       |       |       |       |       |       |       |       |
      | LayoutLOAddGOAllowedAttribut              | Attributes allowed on <listOfAdditionalGraphicalObjectGlyphs>.                                       |       |       |       |       |       |       |       |       |
      | LayoutLOAddGOAllowedElements              | Elements allowed on <listOfAdditionalGraphicalObjectGlyphs>.                                         |       |       |       |       |       |       |       |       |
      | LayoutLayoutMustHaveDimensions            | Layout must have <dimensions>.                                                                       |       |       |       |       |       |       |       |       |
      | LayoutLOTextGlyphAllowedAttributes        | Attributes allowed on <listOfTextGlyphs>.                                                            |       |       |       |       |       |       |       |       |
      | LayoutLOTextGlyphAllowedElements          | Elements allowed on <listOfTextGlyphs>.                                                              |       |       |       |       |       |       |       |       |
      | LayoutGOAllowedCoreElements               | Core elements allowed on <graphicalObject>.                                                          |       |       |       |       |       |       |       |       |
      | LayoutGOAllowedCoreAttributes             | Core attributes allowed on <graphicalObject>.                                                        |       |       |       |       |       |       |       |       |
      | LayoutGOAllowedElements                   | Layout elements allowed on <graphicalObject>.                                                        |       |       |       |       |       |       |       |       |
      | LayoutGOAllowedAttributes                 | Layout attributes allowed on <graphicalObject>.                                                      |       |       |       |       |       |       |       |       |
      | LayoutGOMetaIdRefMustBeIDREF              | Layout 'metaidRef' must be IDREF.                                                                    |       |       |       |       |       |       |       |       |
      | LayoutGOMetaIdRefMustReferenceObject      | Layout 'metaidRef' must reference existing object.                                                   |       |       |       |       |       |       |       |       |
      | LayoutGOMustContainBoundingBox            | A <graphicalObject> must contain a <boundingBox>.                                                    |       |       |       |       |       |       |       |       |
      | LayoutCGAllowedCoreElements               | Core elements allowed on <compartmentGlyph>.                                                         |       |       |       |       |       |       |       |       |
      | LayoutCGAllowedCoreAttributes             | Core attributes allowed on <compartmentGlyph>.                                                       |       |       |       |       |       |       |       |       |
      | LayoutCGAllowedElements                   | Layout elements allowed on <compartmentGlyph>.                                                       |       |       |       |       |       |       |       |       |
      | LayoutCGAllowedAttributes                 | Layout attributes allowed on <compartmentGlyph>.                                                     |       |       |       |       |       |       |       |       |
      | LayoutCGMetaIdRefMustBeIDREF              | Layout 'metaidRef' must be IDREF.                                                                    |       |       |       |       |       |       |       |       |
      | LayoutCGMetaIdRefMustReferenceObject      | Layout 'metaidRef' must reference existing object.                                                   |       |       |       |       |       |       |       |       |
      | LayoutCGCompartmentSyntax                 | CompartmentGlyph 'compartment' must have SIdRef syntax.                                              |       |       |       |       |       |       |       |       |
      | LayoutCGCompartmentMustRefComp            | CompartmentGlyph compartment must reference existing compartment.                                    |       |       |       |       |       |       |       |       |
      | LayoutCGNoDuplicateReferences             | CompartmentGlyph cannot reference two objects.                                                       |       |       |       |       |       |       |       |       |
      | LayoutCGOrderMustBeDouble                 | CompartmentGlyph order must be double.                                                               |       |       |       |       |       |       |       |       |
      | LayoutSGAllowedCoreElements               | Core elements allowed on <speciesGlyph>.                                                             |       |       |       |       |       |       |       |       |
      | LayoutSGAllowedCoreAttributes             | Core attributes allowed on <speciesGlyph>.                                                           |       |       |       |       |       |       |       |       |
      | LayoutSGAllowedElements                   | Layout elements allowed on <speciesGlyph>.                                                           |       |       |       |       |       |       |       |       |
      | LayoutSGAllowedAttributes                 | Layout attributes allowed on <speciesGlyph>.                                                         |       |       |       |       |       |       |       |       |
      | LayoutSGMetaIdRefMustBeIDREF              | Layout 'metaidRef' must be IDREF.                                                                    |       |       |       |       |       |       |       |       |
      | LayoutSGMetaIdRefMustReferenceObject      | Layout 'metaidRef' must reference existing object.                                                   |       |       |       |       |       |       |       |       |
      | LayoutSGSpeciesSyntax                     | SpeciesGlyph 'species' must have SIdRef syntax.                                                      |       |       |       |       |       |       |       |       |
      | LayoutSGSpeciesMustRefSpecies             | SpeciesGlyph species must reference existing species.                                                |       |       |       |       |       |       |       |       |
      | LayoutSGNoDuplicateReferences             | SpeciesGlyph cannot reference two objects.                                                           |       |       |       |       |       |       |       |       |
      | LayoutRGAllowedCoreElements               | Core elements allowed on <reactionGlyph>.                                                            |       |       |       |       |       |       |       |       |
      | LayoutRGAllowedCoreAttributes             | Core attributes allowed on <reactionGlyph>.                                                          |       |       |       |       |       |       |       |       |
      | LayoutRGAllowedElements                   | Layout elements allowed on <reactionGlyph>.                                                          |       |       |       |       |       |       |       |       |
      | LayoutRGAllowedAttributes                 | Layout attributes allowed on <reactionGlyph>.                                                        |       |       |       |       |       |       |       |       |
      | LayoutRGMetaIdRefMustBeIDREF              | Layout 'metaidRef' must be IDREF.                                                                    |       |       |       |       |       |       |       |       |
      | LayoutRGMetaIdRefMustReferenceObject      | Layout 'metaidRef' must reference existing object.                                                   |       |       |       |       |       |       |       |       |
      | LayoutRGReactionSyntax                    | ReactionGlyph 'reaction' must have SIdRef syntax.                                                    |       |       |       |       |       |       |       |       |
      | LayoutRGReactionMustRefReaction           | ReactionGlyph reaction must reference existing reaction.                                             |       |       |       |       |       |       |       |       |
      | LayoutRGNoDuplicateReferences             | ReactionGlyph cannot reference two objects.                                                          |       |       |       |       |       |       |       |       |
      | LayoutLOSpeciesRefGlyphAllowedElements    | Allowed elements on ListOfSpeciesReferenceGlyphs                                                     |       |       |       |       |       |       |       |       |
      | LayoutLOSpeciesRefGlyphAllowedAttribs     | Allowed attributes on ListOfSpeciesReferenceGlyphs                                                   |       |       |       |       |       |       |       |       |
      | LayoutLOSpeciesRefGlyphNotEmpty           | ListOfSpeciesReferenceGlyphs not empty                                                               |       |       |       |       |       |       |       |       |
      | LayoutGGAllowedCoreElements               | Core elements allowed on <generalGlyph>.                                                             |       |       |       |       |       |       |       |       |
      | LayoutGGAllowedCoreAttributes             | Core attributes allowed on <generalGlyph>.                                                           |       |       |       |       |       |       |       |       |
      | LayoutGGAllowedElements                   | Layout elements allowed on <generalGlyph>.                                                           |       |       |       |       |       |       |       |       |
      | LayoutGGAllowedAttributes                 | Layout attributes allowed on <generalGlyph>.                                                         |       |       |       |       |       |       |       |       |
      | LayoutGGMetaIdRefMustBeIDREF              | Layout 'metaidRef' must be IDREF.                                                                    |       |       |       |       |       |       |       |       |
      | LayoutGGMetaIdRefMustReferenceObject      | Layout 'metaidRef' must reference existing object.                                                   |       |       |       |       |       |       |       |       |
      | LayoutGGReferenceSyntax                   | GeneralGlyph 'reference' must have SIdRef syntax.                                                    |       |       |       |       |       |       |       |       |
      | LayoutGGReferenceMustRefObject            | GeneralGlyph 'reference' must reference existing element.                                            |       |       |       |       |       |       |       |       |
      | LayoutGGNoDuplicateReferences             | GeneralGlyph cannot reference two objects.                                                           |       |       |       |       |       |       |       |       |
      | LayoutLOReferenceGlyphAllowedElements     | Allowed elements on ListOfReferenceGlyphs                                                            |       |       |       |       |       |       |       |       |
      | LayoutLOReferenceGlyphAllowedAttribs      | Allowed attributes on ListOfReferenceGlyphs                                                          |       |       |       |       |       |       |       |       |
      | LayoutLOSubGlyphAllowedElements           |                                                                                                      |       |       |       |       |       |       |       |       |
      | LayoutLOSubGlyphAllowedAttribs            | Allowed attributes on ListOfSubGlyphs                                                                |       |       |       |       |       |       |       |       |
      | LayoutTGAllowedCoreElements               | Core elements allowed on <textGlyph>.                                                                |       |       |       |       |       |       |       |       |
      | LayoutTGAllowedCoreAttributes             | Core attributes allowed on <textGlyph>.                                                              |       |       |       |       |       |       |       |       |
      | LayoutTGAllowedElements                   | Layout elements allowed on <textGlyph>.                                                              |       |       |       |       |       |       |       |       |
      | LayoutTGAllowedAttributes                 | Layout attributes allowed on <textGlyph>.                                                            |       |       |       |       |       |       |       |       |
      | LayoutTGMetaIdRefMustBeIDREF              | Layout 'metaidRef' must be IDREF.                                                                    |       |       |       |       |       |       |       |       |
      | LayoutTGMetaIdRefMustReferenceObject      | Layout 'metaidRef' must reference existing object.                                                   |       |       |       |       |       |       |       |       |
      | LayoutTGOriginOfTextSyntax                | TextGlyph 'originOfText' must have SIdRef syntax.                                                    |       |       |       |       |       |       |       |       |
      | LayoutTGOriginOfTextMustRefObject         | TextGlyph 'originOfText' must reference existing element.                                            |       |       |       |       |       |       |       |       |
      | LayoutTGNoDuplicateReferences             | TextGlyph cannot reference two objects.                                                              |       |       |       |       |       |       |       |       |
      | LayoutTGGraphicalObjectSyntax             | TextGlyph 'graphicalObject' must have SIdRef syntax.                                                 |       |       |       |       |       |       |       |       |
      | LayoutTGGraphicalObjectMustRefObject      | TextGlyph 'graphicalObject' must reference existing element.                                         |       |       |       |       |       |       |       |       |
      | LayoutTGTextMustBeString                  | TextGlyph 'text' must be string.                                                                     |       |       |       |       |       |       |       |       |
      | LayoutSRGAllowedCoreElements              | Core elements allowed on <speciesReferenceGlyphgt;.                                                  |       |       |       |       |       |       |       |       |
      | LayoutSRGAllowedCoreAttributes            | Core attributes allowed on <speciesReferenceGlyphgt;.                                                |       |       |       |       |       |       |       |       |
      | LayoutSRGAllowedElements                  | Layout elements allowed on <speciesReferenceGlyphgt;.                                                |       |       |       |       |       |       |       |       |
      | LayoutSRGAllowedAttributes                | Layout attributes allowed on <speciesReferenceGlyphgt;.                                              |       |       |       |       |       |       |       |       |
      | LayoutSRGMetaIdRefMustBeIDREF             | Layout 'metaidRef' must be IDREF.                                                                    |       |       |       |       |       |       |       |       |
      | LayoutSRGMetaIdRefMustReferenceObject     | Layout 'metaidRef' must reference existing object.                                                   |       |       |       |       |       |       |       |       |
      | LayoutSRGSpeciesReferenceSyntax           | SpeciesReferenceGlyph 'speciesReference' must have SIdRef syntax.                                    |       |       |       |       |       |       |       |       |
      | LayoutSRGSpeciesRefMustRefObject          | SpeciesReferenceGlyph 'speciesReference' must reference existing element.                            |       |       |       |       |       |       |       |       |
      | LayoutSRGNoDuplicateReferences            | SpeciesReferenceGlyph cannot reference two objects.                                                  |       |       |       |       |       |       |       |       |
      | LayoutSRGSpeciesGlyphSyntax               | SpeciesReferenceGlyph 'speciesGlyph' must have SIdRef syntax.                                        |       |       |       |       |       |       |       |       |
      | LayoutSRGSpeciesGlyphMustRefObject        | SpeciesReferenceGlyph 'speciesGlyph' must reference existing element.                                |       |       |       |       |       |       |       |       |
      | LayoutSRGRoleSyntax                       | SpeciesReferenceGlyph 'role' must be string from enumeration.                                        |       |       |       |       |       |       |       |       |
      | LayoutREFGAllowedCoreElements             | Core elements allowed on <referenceGlyph>.                                                           |       |       |       |       |       |       |       |       |
      | LayoutREFGAllowedCoreAttributes           | Core attributes allowed on <referenceGlyph>.                                                         |       |       |       |       |       |       |       |       |
      | LayoutREFGAllowedElements                 | Layout elements allowed on <referenceGlyph>.                                                         |       |       |       |       |       |       |       |       |
      | LayoutREFGAllowedAttributes               | Layout attributes allowed on <referenceGlyph>.                                                       |       |       |       |       |       |       |       |       |
      | LayoutREFGMetaIdRefMustBeIDREF            | Layout 'metaidRef' must be IDREF.                                                                    |       |       |       |       |       |       |       |       |
      | LayoutREFGMetaIdRefMustReferenceObject    | Layout 'metaidRef' must reference existing object.                                                   |       |       |       |       |       |       |       |       |
      | LayoutREFGReferenceSyntax                 | ReferenceGlyph 'reference' must have SIdRef syntax.                                                  |       |       |       |       |       |       |       |       |
      | LayoutREFGReferenceMustRefObject          | ReferenceGlyph 'reference' must reference existing element.                                          |       |       |       |       |       |       |       |       |
      | LayoutREFGNoDuplicateReferences           | ReferenceGlyph cannot reference two objects.                                                         |       |       |       |       |       |       |       |       |
      | LayoutREFGGlyphSyntax                     | ReferenceGlyph 'glyph' must have SIdRef syntax.                                                      |       |       |       |       |       |       |       |       |
      | LayoutREFGGlyphMustRefObject              | ReferenceGlyph 'glyph' must reference existing element.                                              |       |       |       |       |       |       |       |       |
      | LayoutREFGRoleSyntax                      | ReferenceGlyph 'role' must be string.                                                                |       |       |       |       |       |       |       |       |
      | LayoutPointAllowedCoreElements            | Core elements allowed on <pointgt;.                                                                  |       |       |       |       |       |       |       |       |
      | LayoutPointAllowedCoreAttributes          | Core attributes allowed on <pointgt;.                                                                |       |       |       |       |       |       |       |       |
      | LayoutPointAllowedAttributes              | Layout attributes allowed on <pointgt;.                                                              |       |       |       |       |       |       |       |       |
      | LayoutPointAttributesMustBeDouble         | Layout 'x', 'y' and 'z' must be double.                                                              |       |       |       |       |       |       |       |       |
      | LayoutBBoxAllowedCoreElements             | Core elements allowed on <boundingBox>.                                                              |       |       |       |       |       |       |       |       |
      | LayoutBBoxAllowedCoreAttributes           | Core attributes allowed on <boundingBox>.                                                            |       |       |       |       |       |       |       |       |
      | LayoutBBoxAllowedElements                 | Layout elements allowed on <boundingBox>.                                                            |       |       |       |       |       |       |       |       |
      | LayoutBBoxAllowedAttributes               | Layout attributes allowed on <boundingBox>.                                                          |       |       |       |       |       |       |       |       |
      | LayoutBBoxConsistent3DDefinition          | Layout consistent dimensions on a <boundingBox>                                                      |       |       |       |       |       |       |       |       |
      | LayoutCurveAllowedCoreElements            | Core elements allowed on <curve>.                                                                    |       |       |       |       |       |       |       |       |
      | LayoutCurveAllowedCoreAttributes          | Core attributes allowed on <curve>.                                                                  |       |       |       |       |       |       |       |       |
      | LayoutCurveAllowedElements                | Layout elements allowed on <curve>.                                                                  |       |       |       |       |       |       |       |       |
      | LayoutCurveAllowedAttributes              | Layout attributes allowed on <curve>.                                                                |       |       |       |       |       |       |       |       |
      | LayoutLOCurveSegsAllowedAttributes        | Allowed attributes on ListOfCurveSegments                                                            |       |       |       |       |       |       |       |       |
      | LayoutLOCurveSegsAllowedElements          | Allowed elements on ListOfCurveSegments                                                              |       |       |       |       |       |       |       |       |
      | LayoutLOCurveSegsNotEmpty                 | No empty ListOfCurveSegments                                                                         |       |       |       |       |       |       |       |       |
      | LayoutLSegAllowedCoreElements             | Core elements allowed on <lineSegment>.                                                              |       |       |       |       |       |       |       |       |
      | LayoutLSegAllowedCoreAttributes           | Core attributes allowed on <lineSegment>.                                                            |       |       |       |       |       |       |       |       |
      | LayoutLSegAllowedElements                 | Layout elements allowed on <lineSegment>.                                                            |       |       |       |       |       |       |       |       |
      | LayoutLSegAllowedAttributes               | Layout attributes allowed on <lineSegment>.                                                          |       |       |       |       |       |       |       |       |
      | LayoutCBezAllowedCoreElements             | Core elements allowed on <cubicBezier>.                                                              |       |       |       |       |       |       |       |       |
      | LayoutCBezAllowedCoreAttributes           | Core attributes allowed on <cubicBezier>.                                                            |       |       |       |       |       |       |       |       |
      | LayoutCBezAllowedElements                 | Layout elements allowed on <cubicBezier>.                                                            |       |       |       |       |       |       |       |       |
      | LayoutCBezAllowedAttributes               | Layout attributes allowed on <cubicBezier>.                                                          |       |       |       |       |       |       |       |       |
      | LayoutDimsAllowedCoreElements             | Core elements allowed on <dimensions>.                                                               |       |       |       |       |       |       |       |       |
      | LayoutDimsAllowedCoreAttributes           | Core attributes allowed on <dimensions>.                                                             |       |       |       |       |       |       |       |       |
      | LayoutDimsAllowedAttributes               | Layout attributes allowed on <dimensions>.                                                           |       |       |       |       |       |       |       |       |
      | LayoutDimsAttributesMustBeDouble          | Layout 'width', 'height' and 'depth' must be double.                                                 |       |       |       |       |       |       |       |       |
      +-------------------------------------------+------------------------------------------------------------------------------------------------------+-------+-------+-------+-------+-------+-------+-------+-------+

    Category codes associated with SBMLError objects
    ......................................................................

    As discussed above, each SBMLError object contains a value for a
    category identifier, describing the type of issue that the SBMLError
    object represents.  The category can be retrieved from an SBMLError
    object using the method SBMLError.getCategory().  The following table
    lists each possible value and a brief description of its meaning.

    As is the case with the error codes, in the libSBML Python language
    interface, the category identifiers are currently implemented as
    static integer constants defined in the interface class libsbml.

    The following table lists each possible value and a brief description
    of its meaning.

    <center>

       LIBSBML_CAT_SBML                    General error not falling into another category below.                                                                                                                                                                                                                                     
       LIBSBML_CAT_SBML_L1_COMPAT          Category of errors that can only occur during attempted translation from one Level/Version of SBML to another.  This particular category applies to errors encountered while trying to convert a model from SBML Level 2 to SBML Level 1.                                                  
       LIBSBML_CAT_SBML_L2V1_COMPAT        Category of errors that can only occur during attempted translation from one Level/Version of SBML to another.  This particular category applies to errors encountered while trying to convert a model to SBML Level 2 Version 1.                                                          
       LIBSBML_CAT_SBML_L2V2_COMPAT        Category of errors that can only occur during attempted translation from one Level/Version of SBML to another.  This particular category applies to errors encountered while trying to convert a model to SBML Level 2 Version 2.                                                          
       LIBSBML_CAT_GENERAL_CONSISTENCY     Category of errors that can occur while validating general SBML constructs.  With respect to the SBML specification, these concern failures in applying the validation rules numbered 2xxxx in the Level 2 Versions 2-4 and Level 3 Versions 1-2 specifications.                           
       LIBSBML_CAT_IDENTIFIER_CONSISTENCY  Category of errors that can occur while validating symbol identifiers in a model. With respect to the SBML specification, these concern failures in applying the validation rules numbered 103xx in the Level 2 Versions 2-4 and Level 3 Versions 1-2 specifications.                      
       LIBSBML_CAT_UNITS_CONSISTENCY       Category of errors that can occur while validating the units of measurement on quantities in a model.  With respect to the SBML specification, these concern failures in applying the validation rules numbered 105xx in the Level 2 Versions 2-4 and Level 3 Versions 1-2 specifications. 
       LIBSBML_CAT_MATHML_CONSISTENCY      Category of errors that can occur while validating MathML formulas in a model.  With respect to the SBML specification, these concern failures in applying the validation rules numbered 102xx in the Level 2 Versions 2-4 and Level 3 Versions 1-2 specifications.                        
       LIBSBML_CAT_SBO_CONSISTENCY         Category of errors that can occur while validating SBO identifiers in a model.  With respect to the SBML specification, these concern failures in applying the validation rules numbered 107xx in the Level 2 Versions 2-4 and Level 3 Versions 1-2 specifications.                        
       LIBSBML_CAT_OVERDETERMINED_MODEL    Error in the system of equations in the model: the system is overdetermined, therefore violating a tenet of proper SBML.  With respect to the SBML specification, this is validation rule #10601 in the SBML Level 2 Versions 2-4 and Level 3 Versions 1-2 specifications.                 
       LIBSBML_CAT_SBML_L2V3_COMPAT        Category of errors that can only occur during attempted translation from one Level/Version of SBML to another.  This particular category applies to errors encountered while trying to convert a model to SBML Level 2 Version 3.                                                          
       LIBSBML_CAT_MODELING_PRACTICE       Category of warnings about recommended good practices involving SBML and computational modeling.  (These are tests performed by libSBML and do not have equivalent SBML validation rules.)                                                                                                 
       LIBSBML_CAT_INTERNAL_CONSISTENCY    Category of errors that can occur while validating libSBML's internal representation of SBML constructs. (These are tests performed by libSBML and do not have equivalent SBML validation rules.)                                                                                          
       LIBSBML_CAT_SBML_L2V4_COMPAT        Category of errors that can only occur during attempted translation from one Level/Version of SBML to another.  This particular category applies to errors encountered while trying to convert a model to SBML Level 2 Version 4.                                                          
       LIBSBML_CAT_SBML_L3V1_COMPAT        Category of errors that can only occur during attempted translation from one Level/Version of SBML to another.  This particular category applies to errors encountered while trying to convert a model to SBML Level 3 Version 1.

    </center>

    <a class='anchor' name='SBMLErrorSeverity_t'>Severity codes associated
    with SBMLError objects
    ......................................................................

    In libSBML version 5.18.0

    there are no additional severity codes beyond those defined by
    XMLError. They are implemented as static integer constants defined in
    the interface class libsbml, and have names beginning with
    LIBSBML_SEV_.

    """

    __swig_setmethods__ = {}
    for _s in [XMLError]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLError, name, value)
    __swig_getmethods__ = {}
    for _s in [XMLError]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SBMLError, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(SBMLError self, unsigned int const errorId=0, unsigned int const level, unsigned int const version, string details, unsigned int const line=0, unsigned int const column=0, unsigned int const severity=LIBSBML_SEV_ERROR, unsigned int const category=LIBSBML_CAT_SBML, string package, unsigned int const pkgVersion=1) -> SBMLError
        __init__(SBMLError self, unsigned int const errorId=0, unsigned int const level, unsigned int const version, string details, unsigned int const line=0, unsigned int const column=0, unsigned int const severity=LIBSBML_SEV_ERROR, unsigned int const category=LIBSBML_CAT_SBML, string package) -> SBMLError
        __init__(SBMLError self, unsigned int const errorId=0, unsigned int const level, unsigned int const version, string details, unsigned int const line=0, unsigned int const column=0, unsigned int const severity=LIBSBML_SEV_ERROR, unsigned int const category=LIBSBML_CAT_SBML) -> SBMLError
        __init__(SBMLError self, unsigned int const errorId=0, unsigned int const level, unsigned int const version, string details, unsigned int const line=0, unsigned int const column=0, unsigned int const severity=LIBSBML_SEV_ERROR) -> SBMLError
        __init__(SBMLError self, unsigned int const errorId=0, unsigned int const level, unsigned int const version, string details, unsigned int const line=0, unsigned int const column=0) -> SBMLError
        __init__(SBMLError self, unsigned int const errorId=0, unsigned int const level, unsigned int const version, string details, unsigned int const line=0) -> SBMLError
        __init__(SBMLError self, unsigned int const errorId=0, unsigned int const level, unsigned int const version, string details) -> SBMLError
        __init__(SBMLError self, unsigned int const errorId=0, unsigned int const level, unsigned int const version) -> SBMLError
        __init__(SBMLError self, unsigned int const errorId=0, unsigned int const level) -> SBMLError
        __init__(SBMLError self, unsigned int const errorId=0) -> SBMLError
        __init__(SBMLError self) -> SBMLError
        __init__(SBMLError self, SBMLError orig) -> SBMLError


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            SBMLError(SBMLError orig)

        Copy constructor; creates a copy of this SBMLError.

        Parameter 'orig' is the instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            SBMLError(  long errorId  = 0 ,  long level    =
        SBML_DEFAULT_LEVEL ,  long version  = SBML_DEFAULT_VERSION , string
        details  = '' ,  long line     = 0 ,  long column   = 0 ,  long
        severity = LIBSBML_SEV_ERROR ,  long category = LIBSBML_CAT_SBML ,
        string package  = 'core' ,  long pkgVersion = 1 )

        Creates a new SBMLError to report that something occurred during SBML
        processing.

        When a libSBML operation on SBML content results in a warning, error
        or other diagnostic, the issue is reported as an SBMLError object.
        SBMLError objects have identification numbers to indicate the nature
        of the exception.  These numbers are defined as longeger constants in
        the interface class libsbml.  See the top of this documentation page
        for a table listing the possible values and their meanings.  The
        argument 'errorId' to this constructor can be (but does not have to
        be) a value from this set of constants.  If it is one of the
        predefined error identifiers, the SBMLError class assumes the error is
        a low-level system or SBML layer error and prepends a built-in,
        predefined error message to any string passed in the argument
        'details' to this constructor.  In addition, all the predefined error
        identifiers have associated values for the 'severity' and 'category'
        codes, and these fields are filled-in using the libSBML defaults for
        each different error identifier.

        If the error identifier 'errorId' is a number greater than 99999, the
        SBMLError class assumes the error was generated from another part of
        the software and does not do additional filling in of values beyond
        the default in the constructor itself.  This allows SBMLError to serve
        as a base class for other errors, such as for user-defined validation
        rules (see Validator).  Callers should fill in all the parameters with
        suitable values if generating errors with codes greater than 99999 to
        make maximum use of the SBMLError facilities.

        As mentioned above, there are additional constants defined for
        standard severity and standard category codes, and every predefined
        error in libSBML has an associated value for severity and category
        taken from these predefined sets.  These constants have symbol names
        prefixed with LIBSBML_SEV_ and LIBSBML_CAT_, respectively.  If the
        value of 'errorId' is one of the standard error codes, callers do not
        need to fill in 'severity' and 'category' in a call to this
        constructor.  Conversely, if 'errorId' is not an existing SBML-level
        error code, callers can use other values for 'severity' and
        'category'.

        Please see the top of the documentation for SBMLError for a longer
        discussion of the possible error codes, their meanings, and their
        applicability to different combinations of Level+Version of SBML.

        Parameter 'errorId' is a long integer, the identification number of
        the error.

        Parameter 'level' is the SBML Level of the SBML model.

        Parameter 'version' is the SBML Version within the Level of the SBML
        model.

        Parameter 'details' is a string containing additional details about
        the error. If the error code in 'errorId' is one that is recognized by
        SBMLError, the given message is appended to a predefined message
        associated with the given code.  If the error code is not recognized,
        the message is stored as-is as the text of the error.

        Parameter 'line' is a long integer, the line number at which the error
        occured.

        Parameter 'column' is a long integer, the column number at which the
        error occured.

        Parameter 'severity' is an integer indicating severity of the error.

        Parameter 'category' is an integer indicating the category to which
        the error belongs.

        Parameter 'package' is the SBML Level package involved.

        Parameter 'pkgVersion' is the version of the 'package'.

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        this = _libsbml.new_SBMLError(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_SBMLError
    __del__ = lambda self: None
SBMLError_swigregister = _libsbml.SBMLError_swigregister
SBMLError_swigregister(SBMLError)

MODEL_QUALIFIER = _libsbml.MODEL_QUALIFIER
BIOLOGICAL_QUALIFIER = _libsbml.BIOLOGICAL_QUALIFIER
UNKNOWN_QUALIFIER = _libsbml.UNKNOWN_QUALIFIER
BQM_IS = _libsbml.BQM_IS
BQM_IS_DESCRIBED_BY = _libsbml.BQM_IS_DESCRIBED_BY
BQM_IS_DERIVED_FROM = _libsbml.BQM_IS_DERIVED_FROM
BQM_IS_INSTANCE_OF = _libsbml.BQM_IS_INSTANCE_OF
BQM_HAS_INSTANCE = _libsbml.BQM_HAS_INSTANCE
BQM_UNKNOWN = _libsbml.BQM_UNKNOWN
BQB_IS = _libsbml.BQB_IS
BQB_HAS_PART = _libsbml.BQB_HAS_PART
BQB_IS_PART_OF = _libsbml.BQB_IS_PART_OF
BQB_IS_VERSION_OF = _libsbml.BQB_IS_VERSION_OF
BQB_HAS_VERSION = _libsbml.BQB_HAS_VERSION
BQB_IS_HOMOLOG_TO = _libsbml.BQB_IS_HOMOLOG_TO
BQB_IS_DESCRIBED_BY = _libsbml.BQB_IS_DESCRIBED_BY
BQB_IS_ENCODED_BY = _libsbml.BQB_IS_ENCODED_BY
BQB_ENCODES = _libsbml.BQB_ENCODES
BQB_OCCURS_IN = _libsbml.BQB_OCCURS_IN
BQB_HAS_PROPERTY = _libsbml.BQB_HAS_PROPERTY
BQB_IS_PROPERTY_OF = _libsbml.BQB_IS_PROPERTY_OF
BQB_HAS_TAXON = _libsbml.BQB_HAS_TAXON
BQB_UNKNOWN = _libsbml.BQB_UNKNOWN
class CVTerm(_object):
    """

    A MIRIAM-compliant controlled vocabulary term.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    The SBML Level 2 and Level 3 specifications define a simple format
    for annotating models when (a) referring to controlled vocabulary
    terms and database identifiers that define and describe biological and
    biochemical entities, and (b) describing the creator of a model and
    the model's modification history.  This SBML format is a concrete
    syntax that conforms to the guidelines of MIRIAM ('Minimum Information
    Requested in the Annotation of biochemical Models', Nature
    Biotechnology, vol. 23, no. 12, Dec. 2005).  The format uses a subset
    of W3C RDF (Resource Description Format).  In order to help
    application developers work with annotations in this format, libSBML
    provides several helper classes that provide higher-level interfaces
    to the data elements; these classes include CVTerm, ModelCreator,
    ModelHistory, RDFAnnotationParser, and Date.

    Components of an SBML annotation
    ======================================================================

    The SBML annotation format consists of RDF-based content placed inside
    an <annotation> element attached to an SBML component such as Species,
    Compartment, etc.  A small change was introduced in SBML Level 2
    Version 5 and SBML Level 3 Version 2 to permit nested annotations:
    lower Versions of the SBML specifications did not explicitly allow
    this.  We first describe the different parts of SBML annotations in
    XML form for SBML Level 2 below Version 5 and SBML Level 3 below
    Version 2:

       <SBML_ELEMENT +++ metaid="meta id" +++>
         +++
         <annotation>
           +++
           <rdf:RDF xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#'
                    xmlns:dcterm='http://purl.org/dc/terms/'
                    xmlns:vcard='http://www.w3.org/2001/vcard-rdf/3.0#'
                    xmlns:bqbiol='http://biomodels.net/biology-qualifiers/'
                    xmlns:bqmodel='http://biomodels.net/model-qualifiers/' >
             <rdf:Description rdf:about="#meta id">
               HISTORY
               <RELATION_ELEMENT>
                 <rdf:Bag>
                   <rdf:li rdf:resource="URI" />
                   ...
                 </rdf:Bag>
               </RELATION_ELEMENT>
               ...
             </rdf:Description>
             +++
           </rdf:RDF>
           +++
         </annotation>
         +++
       </SBML_ELEMENT>

    In the template above, the placeholder SBML_ELEMENT stands for the
    XML tag name of an SBML model component (e.g., model, reaction, etc.)
    and the placeholder  meta id stands for the element's meta identifier,
    which is a field available on all SBML components derived from the
    SBase base object class. The dotted portions are optional, the symbol
    +++ is a placeholder for either no content or valid XML content that
    is not defined by this annotation scheme, and the ellipses ... are
    placeholders for zero or more elements of the same form as the
    immediately preceding element.  The optional content HISTORY is a
    creation and modification history; in libSBML, this is stored using
    ModelHistory objects.

    The placeholder RELATION_ELEMENT refers to a BioModels.net qualifier
    element name.  This is an element in either the XML namespace
    'http://biomodels.net/model-qualifiers' (for model qualifiers) or
    'http://biomodels.net/biology-qualifiers' (for biological qualifier).
    Note that these namespace URIs are only labels, and not actual Web
    locations, which means you cannot visit an address such as
    'http://biomodels.net/model-qualifiers' in your browser or try to have
    your application access it.

    The URI is a required data value that uniquely identifies a resource
    and data within that resource to which the annotation refers.  Again,
    being URIs, these do not refer to physical Web locations;
    nevertheless, applications will often want a means of finding the
    resource to which a given URI refers.  Providing the facilities for
    this task is the purpose of MIRIAM Resources, described in detail
    online at http://biomodels.net/miriam) and also in the paper 'MIRIAM
    Resources: tools to generate and resolve robust cross-references in
    Systems Biology', BMC Systems Biology, 58(1), 2007.

    Finally, the following is the same template as above, but this time
    showing the nested content permitted by the most recent SBML
    specifications (SBML Level 2 Version 5 and Level 3 Version 2):

       <SBML_ELEMENT +++ metaid="meta id" +++>
         +++
         <annotation>
           +++
           <rdf:RDF xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#'
                    xmlns:dcterm='http://purl.org/dc/terms/'
                    xmlns:vcard='http://www.w3.org/2001/vcard-rdf/3.0#'
                    xmlns:bqbiol='http://biomodels.net/biology-qualifiers/'
                    xmlns:bqmodel='http://biomodels.net/model-qualifiers/' >
             <rdf:Description rdf:about="#meta id">
               HISTORY
               <RELATION_ELEMENT>
                 <rdf:Bag>
                   <rdf:li rdf:resource="URI" />
                   NESTED_CONTENT
                   ...
                 </rdf:Bag>
               </RELATION_ELEMENT>
               ...
             </rdf:Description>
             +++
           </rdf:RDF>
           +++
         </annotation>
         +++
       </SBML_ELEMENT>

    The placeholder NESTED_CONTENT refers to other optional RDF elements
    such as 'bqbiol:isDescribedBy' that describe a clarification or
    another annotation about the RELATION_ELEMENT in which it appears.
    Nested content allows one to, for example, describe protein
    modifications on species, or to add evidence codes for an annotation.
    Nested content relates to its containing RELATION_ELEMENT, not the
    other way around.  It qualifies it, but does not change its meaning.
    As such, ignoring a NESTED_CONTENT does not affect the information
    provided by the containing RELATION_ELEMENT.

    For more information about SBML annotations in general, please refer
    to Section 6 in the SBML Level 2 (Versions 2-4) or Level 3
    specification documents.

    The parts of a CVTerm
    ======================================================================

    Annotations that refer to controlled vocabularies are managed in
    libSBML using CVTerm objects.  The relation-resource pairs discussed
    in the previous section are the 'controlled vocabulary' terms that
    CVTerm is designed to store and manipulate.  A set of RDF-based
    annotations attached to a given SBML <annotation> element are read by
    RDFAnnotationParser and converted into a list of these CVTerm objects.
    Each CVTerm object instance stores the following components of an
    annotation:

    * The qualifier, which can be a BioModels.net 'biological
    qualifier', a BioModels.net 'model qualifier', or an unknown qualifier
    (as far as the CVTerm class is concerned).  Qualifiers are used in
    MIRIAM to indicate the nature of the relationship between the object
    being annotated and the resource.  In CVTerm, the qualifiers can be
    manipulated using the methods CVTerm.getQualifierType(),
    CVTerm.setQualifierType(), and related methods.

    * The resource, represented by a URI (which, we must remind
    developers, is not the same as a URL).  In the CVTerm class, the
    resource component can be manipulated using the methods
    CVTerm.addResource() and CVTerm.removeResource().

    Note that a CVTerm contains a single qualifier, but possibly more than
    one resource.  This corresponds to the possibility of an annotation
    that points to multiple resources, all of which are qualified by the
    same BioModels.net qualifier.  The CVTerm object class supports this
    by supporting a list of resources.

    Detailed explanations of the qualifiers defined by BioModels.net can
    be found at http://co.mbine.org/standards/qualifiers.

    """

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CVTerm, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CVTerm, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_CVTerm
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(CVTerm self, QualifierType_t type=UNKNOWN_QUALIFIER) -> CVTerm
        __init__(CVTerm self) -> CVTerm
        __init__(CVTerm self, XMLNode node) -> CVTerm
        __init__(CVTerm self, CVTerm orig) -> CVTerm


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            CVTerm(CVTerm orig)

        Copy constructor; creates a copy of a CVTerm object.

        Parameter 'orig' is the CVTerm instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            CVTerm( XMLNode node)

        Creates a new CVTerm from the given XMLNode.

        The SBML Level 2 and Level 3 specifications define a simple format
        for annotating models when (a) referring to controlled vocabulary
        terms and database identifiers that define and describe biological and
        other entities, and (b) describing the creator of a model and the
        model's modification history.  The annotation content is stored in
        <annotation> elements attached to individual SBML elements.  The
        format for storing the content inside SBML <annotation> elements is a
        subset of W3C RDF (Resource Description Format) expressed in XML.  The
        CVTerm class provides a programming interface for working directly
        with controlled vocabulary term ('CV term') objects without having to
        deal directly with the XML form. When libSBML reads in an SBML model
        containing RDF annotations, it parses those annotations into a list of
        CVTerm objects, and when writing a model, it parses the CVTerm objects
        back into the appropriate SBML <annotation> structure.

        This method creates a CVTerm object from the given XMLNode object
        'node'.  XMLNode is libSBML's representation of a node in an XML tree
        of elements, and each such element can be placed in a namespace.  This
        constructor looks for the element to be in the XML namespaces
        'http://biomodels.net/model-qualifiers' (for model qualifiers) and
        'http://biomodels.net/biology-qualifiers' (for biological qualifier),
        and if they are, creates CVTerm objects for the result.

        Parameter 'node' is an XMLNode representing a CVTerm.

        Note: This method assumes that the given XMLNode object 'node' is of
        the correct structural form.

        ______________________________________________________________________
        Method variant with the following signature:

            CVTerm(QualifierType_t type = UNKNOWN_QUALIFIER)

        Creates an empty CVTerm, optionally with the given qualifier 'type' .

        The SBML Level 2 and Level 3 specifications define a simple format
        for annotating models when (a) referring to controlled vocabulary
        terms and database identifiers that define and describe biological and
        other entities, and (b) describing the creator of a model and the
        model's modification history.  The annotation content is stored in
        <annotation> elements attached to individual SBML elements.  The
        format for storing the content inside SBML <annotation> elements is a
        subset of W3C RDF (Resource Description Format) expressed in XML.  The
        CVTerm class provides a programming interface for working directly
        with controlled vocabulary term ('CV term') objects without having to
        deal directly with the XML form. When libSBML reads in an SBML model
        containing RDF annotations, it parses those annotations into a list of
        CVTerm objects, and when writing a model, it parses the CVTerm objects
        back into the appropriate SBML <annotation> structure.

        This method creates an empty CVTerm object.  The possible qualifier
        types usable as values of 'type' are MODEL_QUALIFIER and
        BIOLOGICAL_QUALIFIER.  If an explicit value for 'type' is not given,
        this method defaults to using UNKNOWN_QUALIFIER.  The qualifier type
        can be set later using the CVTerm.setQualifierType() method.

        Different BioModels.net qualifier elements encode different types of
        relationships.  Please refer to the SBML specification or the
        BioModels.net qualifiers web page for an explanation of the meaning of
        these different qualifiers.

        Parameter 'type' is a qualifier type.

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        this = _libsbml.new_CVTerm(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(CVTerm self) -> CVTerm


        Creates and returns a deep copy of this CVTerm object.

        Returns the (deep) copy of this CVTerm object.

        """
        return _libsbml.CVTerm_clone(self)


    def getQualifierType(self, *args):
        """
        getQualifierType(CVTerm self) -> QualifierType_t
        getQualifierType(CVTerm self) -> QualifierType_t


        Returns the qualifier type of this CVTerm object.

        The RDF element used in the SBML format for referring to external
        entities is <rdf:Description>, with a <rdf:Bag> element inside of it
        containing one or more <rdf:li> elements.  The following template
        illustrates the structure:

          <rdf:Description rdf:about="#meta id">
            HISTORY
            <RELATION_ELEMENT>
              <rdf:Bag>
              <rdf:li rdf:resource="resource URI" />
              ...
              </rdf:Bag>
            </RELATION_ELEMENT>
            ...
          </rdf:Description>

        In the template above, the placeholder meta id stands for the
        element's meta identifier, which is a field available on all SBML
        components derived from the SBase base object class.  The dotted
        portions are optional, and the ellipses ... are placeholders for zero
        or more elements of the same form as the immediately preceding
        element.

        The placeholder  RELATION_ELEMENT refers to a BioModels.net qualifier
        element name.  This is an element in either the XML namespace
        'http://biomodels.net/model-qualifiers' (for model qualifiers) or
        'http://biomodels.net/biology-qualifiers' (for biological qualifier).
        The present method returns a code identifying which one of these two
        relationship namespaces is being used; any other qualifier in libSBML
        is considered unknown (as far as the CVTerm class is concerned).
        Consequently, this method will return one of the following values:

        * MODEL_QUALIFIER

        * BIOLOGICAL_QUALIFIER

        * UNKNOWN_QUALIFIER

        The specific relationship of this CVTerm to the enclosing SBML object
        can be determined using the CVTerm methods such as
        CVTerm.getModelQualifierType() and
        CVTerm.getBiologicalQualifierType().  Callers will typically want to
        use the present method to find out which one of the other two methods
        to call to find out the specific relationship.

        Returns the qualifier type of this object or UNKNOWN_QUALIFIER (the
        default).

        See also getResources(), getModelQualifierType(),
        getBiologicalQualifierType().

        """
        return _libsbml.CVTerm_getQualifierType(self, *args)


    def getModelQualifierType(self, *args):
        """
        getModelQualifierType(CVTerm self) -> ModelQualifierType_t
        getModelQualifierType(CVTerm self) -> ModelQualifierType_t


        Returns the model qualifier type of this CVTerm object.

        The RDF element used in the SBML format for referring to external
        entities is <rdf:Description>, with a <rdf:Bag> element inside of it
        containing one or more <rdf:li> elements.  The following template
        illustrates the structure:

          <rdf:Description rdf:about="#meta id">
            HISTORY
            <RELATION_ELEMENT>
              <rdf:Bag>
              <rdf:li rdf:resource="resource URI" />
              ...
              </rdf:Bag>
            </RELATION_ELEMENT>
            ...
          </rdf:Description>

        In the template above, the placeholder meta id stands for the
        element's meta identifier, which is a field available on all SBML
        components derived from the SBase base object class.  The dotted
        portions are optional, and the ellipses ... are placeholders for zero
        or more elements of the same form as the immediately preceding
        element.

        The placeholder  RELATION_ELEMENT refers to a BioModels.net qualifier
        element name.  This is an element in either the XML namespace
        'http://biomodels.net/model-qualifiers' (for model qualifiers) or
        'http://biomodels.net/biology-qualifiers' (for biological qualifier).
        Callers will typically use CVTerm.getQualifierType() to find out the
        type of qualifier relevant to this particular CVTerm object, then if
        it is a model qualifier, use the present method to determine the
        specific qualifier.

        Annotations with model qualifiers express a relationship between an
        annotation resource and the modeling concept represented by a given
        object in the model.  The diagram below illustrates the relationship
        in this case:

        +---------------------+     qualifier     +---------------------+
        |    model element    +------------------>|      annotation     |
        +----------+----------+                   +---------------------+
                   |                                         |
                   | represents                              | represents
                   v                                         v
        +---------------------+    relationship   +---------------------+
        |  modelling object A +------------------>|  modelling object B |
        +---------------------+                   +---------------------+

        The set of known model qualifiers is, at the time of this libSBML
        release, the following:

        * BQM_IS

        * BQM_IS_DESCRIBED_BY

        * BQM_IS_DERIVED_FROM

        * BQM_IS_INSTANCE_OF

        * BQM_HAS_INSTANCE

        Any other BioModels.net qualifier found in the model is considered
        unknown by libSBML and reported as BQM_UNKNOWN.

        Returns the model qualifier type of this object or BQM_UNKNOWN (the
        default).

        """
        return _libsbml.CVTerm_getModelQualifierType(self, *args)


    def getBiologicalQualifierType(self, *args):
        """
        getBiologicalQualifierType(CVTerm self) -> BiolQualifierType_t
        getBiologicalQualifierType(CVTerm self) -> BiolQualifierType_t


        Returns the biological qualifier type of this CVTerm object.

        The RDF element used in the SBML format for referring to external
        entities is <rdf:Description>, with a <rdf:Bag> element inside of it
        containing one or more <rdf:li> elements.  The following template
        illustrates the structure:

          <rdf:Description rdf:about="#meta id">
            HISTORY
            <RELATION_ELEMENT>
              <rdf:Bag>
              <rdf:li rdf:resource="resource URI" />
              ...
              </rdf:Bag>
            </RELATION_ELEMENT>
            ...
          </rdf:Description>

        In the template above, the placeholder meta id stands for the
        element's meta identifier, which is a field available on all SBML
        components derived from the SBase base object class.  The dotted
        portions are optional, and the ellipses ... are placeholders for zero
        or more elements of the same form as the immediately preceding
        element.

        The placeholder  RELATION_ELEMENT refers to a BioModels.net qualifier
        element name.  This is an element in either the XML namespace
        'http://biomodels.net/model-qualifiers' (for model qualifiers) or
        'http://biomodels.net/biology-qualifiers' (for biological qualifier).
        Callers will typically use CVTerm.getQualifierType() to find out the
        type of qualifier relevant to this particular CVTerm object, then if
        it is a biological qualifier, use the present method to determine the
        specific qualifier.

        Annotations with biological qualifiers express a relationship between
        an annotation resource and the biological concept represented by a
        given object in the model.    The diagram below illustrates the
        relationship in this case:

        +---------------------+     qualifier     +---------------------+
        |    model element    +------------------>|      annotation     |
        +----------+----------+                   +---------------------+
                   |                                         |
                   | represents                              | represents
                   v                                         v
        +---------------------+    relationship   +---------------------+
        | biological entity A +------------------>| biological entity B |
        +---------------------+                   +---------------------+

        The set of known biological qualifiers is, at the time of this libSBML
        release, the following:

        * BQB_IS

        * BQB_HAS_PART

        * BQB_IS_PART_OF

        * BQB_IS_VERSION_OF

        * BQB_HAS_VERSION

        * BQB_IS_HOMOLOG_TO

        * BQB_IS_DESCRIBED_BY

        * BQB_IS_ENCODED_BY

        * BQB_ENCODES

        * BQB_OCCURS_IN

        * BQB_HAS_PROPERTY

        * BQB_IS_PROPERTY_OF

        * BQB_HAS_TAXON

        Any other BioModels.net qualifier found in the model is considered
        unknown by libSBML and reported as BQB_UNKNOWN.

        Returns the biology qualifier type of this object or BQB_UNKNOWN (the
        default).

        """
        return _libsbml.CVTerm_getBiologicalQualifierType(self, *args)


    def getResources(self, *args):
        """
        getResources(CVTerm self) -> XMLAttributes
        getResources(CVTerm self) -> XMLAttributes


        Returns the resource references for this CVTerm object.

        The RDF element used in the SBML format for referring to external
        entities is <rdf:Description>, with a <rdf:Bag> element inside of it
        containing one or more <rdf:li> elements.  The following template
        illustrates the structure:

          <rdf:Description rdf:about="#meta id">
            HISTORY
            <RELATION_ELEMENT>
              <rdf:Bag>
              <rdf:li rdf:resource="resource URI" />
              ...
              </rdf:Bag>
            </RELATION_ELEMENT>
            ...
          </rdf:Description>

        In the template above, the placeholder meta id stands for the
        element's meta identifier, which is a field available on all SBML
        components derived from the SBase base object class.  The dotted
        portions are optional, and the ellipses ... are placeholders for zero
        or more elements of the same form as the immediately preceding
        element.

        The resource URI values shown in the template above are stored
        internally in CVTerm objects using an XMLAttributes object.  Each
        attribute stored inside the XMLAttributes will have the same name
        (specifically, "rdf:resource") but a different value, and the value
        will be a  resource URI shown in the XML template above.

        A valid CVTerm entity must always have at least one resource and a
        value for the relationship qualifier.

        Returns the XMLAttributes that store the resources of this CVTerm.

        See also getQualifierType(), addResource(), getResourceURI().

        """
        return _libsbml.CVTerm_getResources(self, *args)


    def getNumResources(self, *args):
        """
        getNumResources(CVTerm self) -> unsigned int
        getNumResources(CVTerm self) -> unsigned int


        Returns the number of resources for this CVTerm object.

        The RDF element used in the SBML format for referring to external
        entities is <rdf:Description>, with a <rdf:Bag> element inside of it
        containing one or more <rdf:li> elements.  The following template
        illustrates the structure:

          <rdf:Description rdf:about="#meta id">
            HISTORY
            <RELATION_ELEMENT>
              <rdf:Bag>
              <rdf:li rdf:resource="resource URI" />
              ...
              </rdf:Bag>
            </RELATION_ELEMENT>
            ...
          </rdf:Description>

        In the template above, the placeholder meta id stands for the
        element's meta identifier, which is a field available on all SBML
        components derived from the SBase base object class.  The dotted
        portions are optional, and the ellipses ... are placeholders for zero
        or more elements of the same form as the immediately preceding
        element.

        The fragment above illustrates that there can be more than one
        resource referenced by a given relationship annotation (i.e., the
        resource URI values associated with a particular RELATION_ELEMENT).
        The present method returns a count of the resources stored in this
        CVTerm object.

        Returns the number of resources in the set of XMLAttributes of this
        CVTerm.

        See also getResources(), getResourceURI().

        """
        return _libsbml.CVTerm_getNumResources(self, *args)


    def getResourceURI(self, *args):
        """
        getResourceURI(CVTerm self, unsigned int n) -> string
        getResourceURI(CVTerm self, unsigned int n) -> string


        Returns the value of the nth resource for this CVTerm object.

        The RDF element used in the SBML format for referring to external
        entities is <rdf:Description>, with a <rdf:Bag> element inside of it
        containing one or more <rdf:li> elements.  The following template
        illustrates the structure:

          <rdf:Description rdf:about="#meta id">
            HISTORY
            <RELATION_ELEMENT>
              <rdf:Bag>
              <rdf:li rdf:resource="resource URI" />
              ...
              </rdf:Bag>
            </RELATION_ELEMENT>
            ...
          </rdf:Description>

        In the template above, the placeholder meta id stands for the
        element's meta identifier, which is a field available on all SBML
        components derived from the SBase base object class.  The dotted
        portions are optional, and the ellipses ... are placeholders for zero
        or more elements of the same form as the immediately preceding
        element.

        The fragment above illustrates that there can be more than one
        resource referenced by a given relationship annotation (i.e., the
        resource URI values associated with a particular RELATION_ELEMENT).
        LibSBML stores all resource URIs in a single CVTerm object for a given
        relationship. Callers can use CVTerm.getNumResources() to find out how
        many resources are stored in this CVTerm object, then call this method
        to retrieve the nth resource URI.

        Parameter 'n' is the index of the resource to query.

        Returns string representing the value of the nth resource in the set
        of XMLAttributes of this CVTerm.

        See also getNumResources(), getQualifierType().

        """
        return _libsbml.CVTerm_getResourceURI(self, *args)


    def setQualifierType(self, type):
        """
        setQualifierType(CVTerm self, QualifierType_t type) -> int


        Sets the qualifier code of this CVTerm object.

        Parameter 'type' is the qualifier type.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        See also getQualifierType().

        """
        return _libsbml.CVTerm_setQualifierType(self, type)


    def setModelQualifierType(self, *args):
        """
        setModelQualifierType(CVTerm self, ModelQualifierType_t type) -> int
        setModelQualifierType(CVTerm self, string qualifier) -> int


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            setModelQualifierType(string qualifier)

        Sets the model qualifier type value of this CVTerm object.

        Parameter 'qualifier' is the string representing a model qualifier.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        Note: If the Qualifier Type of this object is not MODEL_QUALIFIER,
        then the model qualifier type will default to BQM_UNKNOWN.

        See also getQualifierType(), setQualifierType().

        ______________________________________________________________________
        Method variant with the following signature:

            setModelQualifierType(ModelQualifierType_t type)

        Sets the model qualifier type of this CVTerm object.

        Parameter 'type' is the model qualifier type.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        Note: If the qualifier type of this object is not MODEL_QUALIFIER,
        then the then the model qualifier type will default to BQM_UNKNOWN.

        See also getQualifierType(), setQualifierType().

        """
        return _libsbml.CVTerm_setModelQualifierType(self, *args)


    def setBiologicalQualifierType(self, *args):
        """
        setBiologicalQualifierType(CVTerm self, BiolQualifierType_t type) -> int
        setBiologicalQualifierType(CVTerm self, string qualifier) -> int


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            setBiologicalQualifierType(string qualifier)

        Sets the biology qualifier type code of this CVTerm object.

        Parameter 'qualifier' is the string representing a biology qualifier.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        Note: If the Qualifier Type of this object is not
        BIOLOGICAL_QUALIFIER, then the biology qualifier type code will
        default to BQB_UNKNOWN.

        See also getQualifierType(), setQualifierType().

        ______________________________________________________________________
        Method variant with the following signature:

            setBiologicalQualifierType(BiolQualifierType_t type)

        Sets the biology qualifier type of this CVTerm object.

        Parameter 'type' is the biology qualifier type.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        Note: If the Qualifier Type of this object is not
        BIOLOGICAL_QUALIFIER, then the biology qualifier type will default to
        BQB_UNKNOWN.

        See also getQualifierType(), setQualifierType().

        """
        return _libsbml.CVTerm_setBiologicalQualifierType(self, *args)


    def addResource(self, resource):
        """
        addResource(CVTerm self, string resource) -> int


        Adds a resource reference to this CVTerm object.

        The SBML Level 2 and Level 3 specifications define a simple format
        for annotating models when (a) referring to controlled vocabulary
        terms and database identifiers that define and describe biological and
        other entities, and (b) describing the creator of a model and the
        model's modification history.  The annotation content is stored in
        <annotation> elements attached to individual SBML elements.  The
        format for storing the content inside SBML <annotation> elements is a
        subset of W3C RDF (Resource Description Format) expressed in XML.  The
        CVTerm class provides a programming interface for working directly
        with controlled vocabulary term ('CV term') objects without having to
        deal directly with the XML form. When libSBML reads in an SBML model
        containing RDF annotations, it parses those annotations into a list of
        CVTerm objects, and when writing a model, it parses the CVTerm objects
        back into the appropriate SBML <annotation> structure.

        The specific RDF element used in this SBML format for referring to
        external entities is <rdf:Description>, with a <rdf:Bag> element
        containing one or more <rdf:li> elements.  Each such element refers to
        a data item in an external resource; the resource and data item are
        together identified uniquely using a URI.  The following template
        illustrates the structure:

             <rdf:Description rdf:about="#meta id">
               HISTORY
               <RELATION_ELEMENT>
                 <rdf:Bag>
                   <rdf:li rdf:resource="resource URI" />
                   ...
                 </rdf:Bag>
               </RELATION_ELEMENT>
               ...
             </rdf:Description>

        In the template above, the placeholder meta id stands for the
        element's meta identifier, which is a field available on all SBML
        components derived from the SBase base object class.  The dotted
        portions are optional, and the ellipses ... are placeholders for zero
        or more elements of the same form as the immediately preceding
        element. The placeholder  RELATION_ELEMENT refers to a BioModels.net
        qualifier element name.  This is an element in either the XML
        namespace 'http://biomodels.net/model-qualifiers' (for model
        qualifiers) or 'http://biomodels.net/biology-qualifiers' (for
        biological qualifier).

        The resource URI is a required data value that uniquely identifies a
        resource and data within that resource to which the annotation refers.
        The present method allows callers to add a reference to a resource URI
        with the same relationship to the enclosing SBML object.  (In other
        words, the argument to this method is a resource URI as shown in the
        XML fragment above.)  Resources are stored in this CVTerm object
        within an XMLAttributes object.

        The relationship of this CVTerm to the enclosing SBML object can be
        determined using the CVTerm methods such as
        CVTerm.getModelQualifierType() and
        CVTerm.getBiologicalQualifierType().

        Parameter 'resource' is a string representing the URI of the resource
        and data item being referenced; e.g.,
        'http://www.geneontology.org/#GO:0005892'.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getResources(), removeResource(), getQualifierType(),
        getModelQualifierType(), getBiologicalQualifierType().

        """
        return _libsbml.CVTerm_addResource(self, resource)


    def removeResource(self, resource):
        """
        removeResource(CVTerm self, string resource) -> int


        Removes a resource URI from the set of resources stored in this CVTerm
        object.

        Parameter 'resource' is a string representing the resource URI to
        remove; e.g., 'http://www.geneontology.org/#GO:0005892'.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INDEX_EXCEEDS_SIZE

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        See also addResource().

        """
        return _libsbml.CVTerm_removeResource(self, resource)


    def hasBeenModified(self):
        """
        hasBeenModified(CVTerm self) -> bool


        Internal implementation method.

        """
        return _libsbml.CVTerm_hasBeenModified(self)


    def resetModifiedFlags(self):
        """
        resetModifiedFlags(CVTerm self)


        Internal implementation method.

        """
        return _libsbml.CVTerm_resetModifiedFlags(self)


    def hasRequiredAttributes(self, *args):
        """
        hasRequiredAttributes(CVTerm self) -> bool
        hasRequiredAttributes(CVTerm self) -> bool


        Predicate returning 'True' if all the required elements for this
        CVTerm object have been set.

        Note: The required attributes for a CVTerm are:

        * a qualifier type, which can be either a model qualifier or a
        biological qualifier

        * at least one resource

        """
        return _libsbml.CVTerm_hasRequiredAttributes(self, *args)


    def getNumNestedCVTerms(self):
        """
        getNumNestedCVTerms(CVTerm self) -> unsigned int


        Returns the number of CVTerm objects nested within this CVTerm object.

        Returns the number of CVTerms nested within this CVTerm object.

        Note: this does not recurse through potentially nested CVTerm objects
        within a given nested CVTerm. It returns the number of terms
        immediately nested within this CVTerm.

        """
        return _libsbml.CVTerm_getNumNestedCVTerms(self)


    def getNestedCVTerm(self, *args):
        """
        getNestedCVTerm(CVTerm self, unsigned int n) -> CVTerm
        getNestedCVTerm(CVTerm self, unsigned int n) -> CVTerm


        Returns the nth CVTerm in the list of CVTerms of this CVTerm object.

        Parameter 'n' is long the index of the CVTerm to retrieve.

        Returns the nth CVTerm in the list of CVTerms for this CVTerm object
        or 'None' if no such object exists.

        """
        return _libsbml.CVTerm_getNestedCVTerm(self, *args)


    def getListNestedCVTerms(self, *args):
        """
        getListNestedCVTerms(CVTerm self) -> List
        getListNestedCVTerms(CVTerm self) -> List const *


        Returns a list of CVTerm objects contained within this CVTerm object.

        Returns the list of CVTerms for this CVTerm object.

        """
        return _libsbml.CVTerm_getListNestedCVTerms(self, *args)


    def addNestedCVTerm(self, term):
        """
        addNestedCVTerm(CVTerm self, CVTerm term) -> int


        Adds a copy of the given CVTerm object to the list of nested CVTerm
        objects within this CVTerm object.

        Parameter 'term' is the CVTerm to assign.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        """
        return _libsbml.CVTerm_addNestedCVTerm(self, term)


    def removeNestedCVTerm(self, n):
        """
        removeNestedCVTerm(CVTerm self, unsigned int n) -> CVTerm


        Removes the nth CVTerm in the list of CVTerms of this CVTerm object
        and returns a pointer to it.

        Parameter 'n' is long the index of the CVTerm to retrieve.

        Returns a pointer to the nth CVTerm in the list of CVTerms for this
        CVTerm object.

        """
        return _libsbml.CVTerm_removeNestedCVTerm(self, n)


    __metaclass__ = AutoProperty


    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

CVTerm_swigregister = _libsbml.CVTerm_swigregister
CVTerm_swigregister(CVTerm)


def ModelQualifierType_toString(type):
    """
    ModelQualifierType_toString(ModelQualifierType_t type) -> char const *


    This method takes a model qualifier type code and returns a string
    representing the code.

    This method takes a model qualifier type as argument and returns a
    string name corresponding to that code.  For example, passing it the
    qualifier BQM_IS_DESCRIBED_BY will return the string 'isDescribedBy'.

    Parameter 'type' is the  value to translate. The value should be a
    libSBML constant whose name begins with 'BQM_,' such as (for example)
    BQM_IS.

    Returns a human readable qualifier name for the given qualifier type.

    Note: The caller does not own the returned string and is therefore not
    allowed to modify it.

    """
    return _libsbml.ModelQualifierType_toString(type)

def BiolQualifierType_toString(type):
    """
    BiolQualifierType_toString(BiolQualifierType_t type) -> char const *


    This method takes a biol qualifier type code and returns a string
    representing the code.

    This method takes a biol qualifier type as argument and returns a
    string name corresponding to that code.  For example, passing it the
    qualifier BQB_HAS_VERSION will return the string 'hasVersion'.

    Parameter 'type' is the  value to translate. The value should be a
    constant whose name begins with 'BQB_,' such as (for example) BQB_IS.

    Returns a human readable qualifier name for the given type.

    Note: The caller does not own the returned string and is therefore not
    allowed to modify it.

    """
    return _libsbml.BiolQualifierType_toString(type)

def ModelQualifierType_fromString(s):
    """
    ModelQualifierType_fromString(char const * s) -> ModelQualifierType_t


    This method takes a string and returns a model qualifier representing
    the string.

    This method takes a string as argument and returns a model qualifier
    type corresponding to that string.  For example, passing it the string
    'isDescribedBy' will return the qualifier BQM_IS_DESCRIBED_BY.

    Parameter 's' is the string to translate to a libSBML constant value
    representing a model qualifier.

    Returns a libSBML qualifier enumeration value for the given human
    readable qualifier name.

    """
    return _libsbml.ModelQualifierType_fromString(s)

def BiolQualifierType_fromString(s):
    """
    BiolQualifierType_fromString(char const * s) -> BiolQualifierType_t


    This method takes a string and returns a biol qualifier representing
    the string.

    This method takes a string as argument and returns a biol qualifier
    type corresponding to that string.  For example, passing it the string
    'hasVersion' will return the qualifier BQB_HAS_VERSION.

    Parameter 's' is the string to translate to a libSBML constant value
    representing a biological qualifier.

    Returns a libSBML qualifier enumeration value for the given human
    readable qualifier name.

    """
    return _libsbml.BiolQualifierType_fromString(s)
class Date(_object):
    """

    A MIRIAM-compliant date representation.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    A Date object stores a reasonably complete representation of date and
    time.  Its purpose is to serve as a way to store dates to be read and
    written in the W3C date format used in RDF Dublin Core annotations
    within SBML.  The W3C date format is a restricted form of ISO 8601,
    the international standard for the representation of dates and times.
    A time and date value in this W3C format takes the form YYYY-MM-
    DDThh:mm:ssXHH:ZZ (e.g., 1997-07-16T19:20:30+01:00) where XHH:ZZ is
    the time zone offset.  The libSBML Date object contains the following
    fields to represent these values:

    * year: a long integer representing the year.  This should be a
    four-digit number such as '2011.'

    * month: a long integer representing the month, with a range of
    values of 1-12.  The value '1' represents January, and so on.

    * day: a long integer representing the day of the month, with a
    range of values of 1-31.

    * hour: a long integer representing the hour on a 24-hour clock,
    with a range of values of 0-23.

    * minute: a long integer representing the minute, with a range of
    0-59.

    * second: a long integer representing the second, with a range of
    0-59.

    * sign: a long integer representing the sign of the offset ('0'
    signifying '+' and '1' signifying '-).'  See the paragraph below for
    further explanations.

    * hours offset: a long integer representing the time zone's hour
    offset from GMT, with a range of 0-12.

    * minute offset: a long integer representing the time zone's
    minute offset from GMT, with a range of 0-59.

    To illustrate the time zone offset, a value of -05:00 would correspond
    to USA Eastern Standard Time.  In the Date object, this would require
    a value of '1' for the sign field, '5' for the hour offset and '0' for
    the minutes offset.

    In the restricted RDF annotations used in SBML, described in Section 6
    of the SBML Level 2 and Level 3 specification documents, date/time
    stamps can be used to indicate the time of creation and modification
    of a model.  The following SBML model fragment illustrates this:

      <model metaid='_180340' id='GMO' name='Goldbeter1991_MinMitOscil'>
          <annotation>
              <rdf:RDF xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#'
                       xmlns:dc='http://purl.org/dc/elements/1.1/'
                       xmlns:dcterms='http://purl.org/dc/terms/'
                       xmlns:vCard='http://www.w3.org/2001/vcard-rdf/3.0#' >
                  <rdf:Description rdf:about='#_180340'>
                      <dc:creator>
                          <rdf:Bag>
                              <rdf:li rdf:parseType='Resource'>
                                  <vCard:N rdf:parseType='Resource'>
                                      <vCard:Family>Shapiro</vCard:Family>
                                      <vCard:Given>Bruce</vCard:Given>
                                  </vCard:N>
                                  <vCard:EMAIL>bshapiro@jpl.nasa.gov</vCard:EMAIL>
                                  <vCard:ORG rdf:parseType='Resource'>
                                      <vCard:Orgname>NASA Jet Propulsion Laboratory</vCard:Orgname>
                                  </vCard:ORG>
                              </rdf:li>
                          </rdf:Bag>
                      </dc:creator>
                      <dcterms:created rdf:parseType='Resource'>
                          <dcterms:W3CDTF>2005-02-06T23:39:40+00:00</dcterms:W3CDTF>
                      </dcterms:created>
                      <dcterms:modified rdf:parseType='Resource'>
                          <dcterms:W3CDTF>2005-09-13T13:24:56+00:00</dcterms:W3CDTF>
                      </dcterms:modified>
                  </rdf:Description>
              </rdf:RDF>
          </annotation>
      </model>

    """

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Date, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Date, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_Date
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(Date self, unsigned int year=2000, unsigned int month=1, unsigned int day=1, unsigned int hour=0, unsigned int minute=0, unsigned int second=0, unsigned int sign=0, unsigned int hoursOffset=0, unsigned int minutesOffset=0) -> Date
        __init__(Date self, unsigned int year=2000, unsigned int month=1, unsigned int day=1, unsigned int hour=0, unsigned int minute=0, unsigned int second=0, unsigned int sign=0, unsigned int hoursOffset=0) -> Date
        __init__(Date self, unsigned int year=2000, unsigned int month=1, unsigned int day=1, unsigned int hour=0, unsigned int minute=0, unsigned int second=0, unsigned int sign=0) -> Date
        __init__(Date self, unsigned int year=2000, unsigned int month=1, unsigned int day=1, unsigned int hour=0, unsigned int minute=0, unsigned int second=0) -> Date
        __init__(Date self, unsigned int year=2000, unsigned int month=1, unsigned int day=1, unsigned int hour=0, unsigned int minute=0) -> Date
        __init__(Date self, unsigned int year=2000, unsigned int month=1, unsigned int day=1, unsigned int hour=0) -> Date
        __init__(Date self, unsigned int year=2000, unsigned int month=1, unsigned int day=1) -> Date
        __init__(Date self, unsigned int year=2000, unsigned int month=1) -> Date
        __init__(Date self, unsigned int year=2000) -> Date
        __init__(Date self) -> Date
        __init__(Date self, string date) -> Date
        __init__(Date self, Date orig) -> Date


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            Date(string date)

        Creates a Date object from a string expressing a date and time value.

        This constructor expects its argument to be in the W3C date format
        with time zone offset, used in RDF Dublin Core annotations within
        SBML.

        The date format expresses a date and time value as a string of the
        form YYYY-MM-DDThh:mm:ssXHH:ZZ, where

        * YYYY is a four-digit integer representing the year.  This should
        be a four-digit number such as '2011.'

        * MM is a two-digit integer representing the month, with a range
        of values of 01-12.  The value '1' represents January, and so on.

        * DD is a two-digit integer representing the day of the month,
        with a range of values of 01-31.

        * T is the literal character 'T.'

        * hh is a two-digit integer representing the hour on a 24-hour
        clock, with a range of values of 00-23.

        * mm is a two-digit integer representing the minute, with a range
        of 00-59.

        * ss is a two-digit integer representing the second, with a range
        of 0-59.

        * X is the the sign of the time zone offset, either '+' or -.

        * HH is a two-digit integer representing the hour of the time zone
        offset, with a range of 00-23.

        * ZZ is a two-digit integer representing the minutes of the time
        zone offset, with a range of 00-59.

        In the string format above, it is important not to forget the literal
        character 'T' in the string.  Here is an example date/time string:
        1997-07-16T19:20:30+01:00, which would represent July 16, 1997, at
        19:20:30 in Central European Time (which is UTC +1:00).

        If this constructor is given a 'None' argument or a string of length
        zero, it constructs a Date object with the value of January 1, 2000,
        at time 00:00 UTC.  Otherwise, the argument must be in the complete
        format described above, or unpredictable results will happen.

        Parameter 'date' is a string representing the date.

        ______________________________________________________________________
        Method variant with the following signature:

            Date(long year = 2000, long month = 1, long day = 1, long
        hour = 0, long minute = 0, long second = 0, long sign = 0, long
        hoursOffset = 0, long minutesOffset = 0)

        Creates a time and date representation for use in model annotations
        and elsewhere.

        The following is the complete set of possible arguments to this
        constructor, with default values as indicated:

        Parameter 'year' is a long integereger representing the year.  This
        should be a four-digit number such as '2011.'  (Default value used if
        this argument is not given: '2000.)'

        Parameter 'month' is a long integereger representing the month, with a
        range of values of 1-12.  The value '1' represents January, and so on.
        (Default value used if this argument is not given: '1.)'

        Parameter 'day' is a long integereger representing the day of the
        month, with a range of values of 1-31.  (Default value used if this
        argument is not given: '1.)'

        Parameter 'hour' is a long integereger representing the hour on a
        24-hour clock, with a range of values of 0-23.  (Default value used if
        this argument is not given: '0.)'

        Parameter 'minute' is a long integereger representing the minute, with
        a range of 0-59.  (Default value used if this argument is not given:
        '0.)'

        Parameter 'second' is a long integereger representing the second, with
        a range of 0-59.  (Default value used if this argument is not given:
        '0.)'

        Parameter 'sign' is a long integereger representing the sign of the
        offset ('0' signifying '+' and '1' signifying '-).'  See the paragraph
        below for further explanations.  (Default value used if this argument
        is not given: '0.)'

        Parameter 'hoursOffset' is a long integereger representing the time
        zone's hour offset from GMT.  (Default value used if this argument is
        not given: '0.)'

        Parameter 'minutesOffset' is a long integereger representing the time
        zone's minute offset from GMT.  (Default value used if this argument
        is not given: '0.)'

        To illustrate the time zone offset, a value of -05:00 would correspond
        to USA Eastern Standard Time.  In the Date object, this would require
        a value of '1' for the sign field, '5' for the hour offset and '0' for
        the minutes offset.

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            Date(Date orig)

        Copy constructor; creates a copy of this Date.

        Parameter 'orig' is the object to copy.

        """
        this = _libsbml.new_Date(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(Date self) -> Date


        Creates and returns a deep copy of this Date object.

        Returns the (deep) copy of this Date object.

        """
        return _libsbml.Date_clone(self)


    def getYear(self):
        """
        getYear(Date self) -> unsigned int


        Returns the year from this Date.

        Returns the year from this Date.

        """
        return _libsbml.Date_getYear(self)


    def getMonth(self):
        """
        getMonth(Date self) -> unsigned int


        Returns the month from this Date.

        Returns the month from this Date.

        """
        return _libsbml.Date_getMonth(self)


    def getDay(self):
        """
        getDay(Date self) -> unsigned int


        Returns the day from this Date.

        Returns the day from this Date.

        """
        return _libsbml.Date_getDay(self)


    def getHour(self):
        """
        getHour(Date self) -> unsigned int


        Returns the hour from this Date.

        Returns the hour from this Date.

        """
        return _libsbml.Date_getHour(self)


    def getMinute(self):
        """
        getMinute(Date self) -> unsigned int


        Returns the minute from this Date.

        Returns the minute from this Date.

        """
        return _libsbml.Date_getMinute(self)


    def getSecond(self):
        """
        getSecond(Date self) -> unsigned int


        Returns the seconds from this Date.

        Returns the seconds from this Date.

        """
        return _libsbml.Date_getSecond(self)


    def getSignOffset(self):
        """
        getSignOffset(Date self) -> unsigned int


        Returns the sign of the time zone offset from this Date.

        Returns the sign of the offset from this Date.

        """
        return _libsbml.Date_getSignOffset(self)


    def getHoursOffset(self):
        """
        getHoursOffset(Date self) -> unsigned int


        Returns the hours of the time zone offset from this Date.

        Returns the hours of the offset from this Date.

        """
        return _libsbml.Date_getHoursOffset(self)


    def getMinutesOffset(self):
        """
        getMinutesOffset(Date self) -> unsigned int


        Returns the minutes of the time zone offset from this Date.

        Returns the minutes of the offset from this Date.

        """
        return _libsbml.Date_getMinutesOffset(self)


    def getDateAsString(self):
        """
        getDateAsString(Date self) -> string


        Returns the current Date value in text-string form.

        The string returned will be in the W3C date format with time zone
        offset, used in RDF Dublin Core annotations within SBML.

        The date format expresses a date and time value as a string of the
        form YYYY-MM-DDThh:mm:ssXHH:ZZ, where

        * YYYY is a four-digit integer representing the year.  This should
        be a four-digit number such as '2011.'

        * MM is a two-digit integer representing the month, with a range
        of values of 01-12.  The value '1' represents January, and so on.

        * DD is a two-digit integer representing the day of the month,
        with a range of values of 01-31.

        * T is the literal character 'T.'

        * hh is a two-digit integer representing the hour on a 24-hour
        clock, with a range of values of 00-23.

        * mm is a two-digit integer representing the minute, with a range
        of 00-59.

        * ss is a two-digit integer representing the second, with a range
        of 0-59.

        * X is the the sign of the time zone offset, either '+' or -.

        * HH is a two-digit integer representing the hour of the time zone
        offset, with a range of 00-23.

        * ZZ is a two-digit integer representing the minutes of the time
        zone offset, with a range of 00-59.

        In the string format above, it is important not to forget the literal
        character 'T' in the string.  Here is an example date/time string:
        1997-07-16T19:20:30+01:00, which would represent July 16, 1997, at
        19:20:30 in Central European Time (which is UTC +1:00).

        Returns the date as a string.

        """
        return _libsbml.Date_getDateAsString(self)


    def setYear(self, year):
        """
        setYear(Date self, unsigned int year) -> int


        Sets the value of the year of this Date object.

        The value given as argument must be between 1000 and 9999 inclusive.
        (In the millennium during which this libSBML documentation is being
        written, a typical value is '2011,' but we hope that SBML will
        continue to be used for a long time.)

        Parameter 'year' is a long integer representing the year.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Date_setYear(self, year)


    def setMonth(self, month):
        """
        setMonth(Date self, unsigned int month) -> int


        Sets the value of the month of this Date object.

        Parameter 'month' is a long integer representing the month; it must be
        in the range 1-12 or an error will be signaled.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Date_setMonth(self, month)


    def setDay(self, day):
        """
        setDay(Date self, unsigned int day) -> int


        Sets the value of the day of this Date object.

        Parameter 'day' is a long integer representing the day; it must be in
        the range 0-31 or an error will be signaled.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Date_setDay(self, day)


    def setHour(self, hour):
        """
        setHour(Date self, unsigned int hour) -> int


        Sets the value of the hour of this Date object.

        Parameter 'hour' is a long integer representing the hour to set; it
        must be in the range 0-23 or an error will be signaled.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Date_setHour(self, hour)


    def setMinute(self, minute):
        """
        setMinute(Date self, unsigned int minute) -> int


        Sets the value of the minute of this Date object.

        Parameter 'minute' is a long integer representing the minute to set;
        it must be in the range 0-59 or an error will be signaled.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Date_setMinute(self, minute)


    def setSecond(self, second):
        """
        setSecond(Date self, unsigned int second) -> int


        Sets the value of the second of the Date object.

        Parameter 'second' is a long integer representing the seconds; it must
        be in the range 0-59 or an error will be signaled.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Date_setSecond(self, second)


    def setSignOffset(self, sign):
        """
        setSignOffset(Date self, unsigned int sign) -> int


        Sets the value of the sign of the time zone offset of this Date
        object.

        The only permissible values are '0' and '1.'

        Parameter 'sign' is a long integer representing the sign of the
        offset, with '0' signifying '+' and '1' signifying '-.'

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Date_setSignOffset(self, sign)


    def setHoursOffset(self, hoursOffset):
        """
        setHoursOffset(Date self, unsigned int hoursOffset) -> int


        Sets the value of this Date object's time zone hour offset.

        Parameter 'hoursOffset' is a long integer representing the hours of
        the offset; it must be in the range 0-12 or an error will be signaled.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Date_setHoursOffset(self, hoursOffset)


    def setMinutesOffset(self, minutesOffset):
        """
        setMinutesOffset(Date self, unsigned int minutesOffset) -> int


        Sets the value of this Date object's time zone minutes offset.

        Parameter 'minutesOffset' is a long integer representing the minutes
        of the offset; it must be in the range 0-59 or an error will be
        signaled.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Date_setMinutesOffset(self, minutesOffset)


    def setDateAsString(self, date):
        """
        setDateAsString(Date self, string date) -> int


        Sets the value of this Date object using a date and time value
        expressed as a text string.

        This method expects its argument to be in the W3C date format with
        time zone offset, used in RDF Dublin Core annotations within SBML.

        The date format expresses a date and time value as a string of the
        form YYYY-MM-DDThh:mm:ssXHH:ZZ, where

        * YYYY is a four-digit integer representing the year.  This should
        be a four-digit number such as '2011.'

        * MM is a two-digit integer representing the month, with a range
        of values of 01-12.  The value '1' represents January, and so on.

        * DD is a two-digit integer representing the day of the month,
        with a range of values of 01-31.

        * T is the literal character 'T.'

        * hh is a two-digit integer representing the hour on a 24-hour
        clock, with a range of values of 00-23.

        * mm is a two-digit integer representing the minute, with a range
        of 00-59.

        * ss is a two-digit integer representing the second, with a range
        of 0-59.

        * X is the the sign of the time zone offset, either '+' or -.

        * HH is a two-digit integer representing the hour of the time zone
        offset, with a range of 00-23.

        * ZZ is a two-digit integer representing the minutes of the time
        zone offset, with a range of 00-59.

        In the string format above, it is important not to forget the literal
        character 'T' in the string.  Here is an example date/time string:
        1997-07-16T19:20:30+01:00, which would represent July 16, 1997, at
        19:20:30 in Central European Time (which is UTC +1:00).

        If this method is given a 'None' argument or a string of length zero,
        it constructs a Date object with the value of January 1, 2000, at time
        00:00 UTC.  Otherwise, the argument must be in the complete format
        described above, or unpredictable results will happen.

        Parameter 'date' is a string representing the date.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Date_setDateAsString(self, date)


    def representsValidDate(self):
        """
        representsValidDate(Date self) -> bool


        Returns 'True' or 'False' depending on whether this date object
        represents a valid date and time value.

        This method verifies that the date/time value stored in this object is
        well-formed and represents plausible values.  A time and date value in
        the W3C format takes the form YYYY-MM-DDThh:mm:ssXHH:ZZ (e.g.,
        1997-07-16T19:20:30+01:00) where XHH:ZZ is the time zone offset.  This
        method checks such things as whether the value of the month number is
        less than or equal to 12, whether the value of the minutes number is
        less than or equal to 59, whether a time zone offset is set, etc.

        Returns 'True' if the date is valid, 'False' otherwise.

        """
        return _libsbml.Date_representsValidDate(self)


    def hasBeenModified(self):
        """
        hasBeenModified(Date self) -> bool


        Internal implementation method.

        """
        return _libsbml.Date_hasBeenModified(self)


    def resetModifiedFlags(self):
        """
        resetModifiedFlags(Date self)


        Internal implementation method.

        """
        return _libsbml.Date_resetModifiedFlags(self)


    __metaclass__ = AutoProperty


    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

Date_swigregister = _libsbml.Date_swigregister
Date_swigregister(Date)

class ModelCreator(_object):
    """

    MIRIAM-compliant data about a model's creator.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    The SBML specification beginning with Level 2 Version 2 defines a
    standard approach to recording model history and model creator
    information in a form that complies with MIRIAM ('Minimum Information
    Requested in the Annotation of biochemical Models', Nature
    Biotechnology, vol. 23, no. 12, Dec. 2005).  For the model creator,
    this form involves the use of parts of the vCard representation.
    LibSBML provides the ModelCreator class as a convenience high-level
    interface for working with model creator data.  Objects of class
    ModelCreator can be used to store and carry around creator data within
    a program, and the various methods in this object class let callers
    manipulate the different parts of the model creator representation.

    The different parts of a model creator definition
    ======================================================================

    The ModelCreator class mirrors the structure of the MIRIAM model
    creator annotations in SBML.  The following template illustrates these
    different fields when they are written in XML form:

       <vCard:N rdf:parseType='Resource'>
         <vCard:Family>family name</vCard:Family>
         <vCard:Given>given name</vCard:Given>
       </vCard:N>
       ...
       <vCard:EMAIL>email address</vCard:EMAIL>
       ...
       <vCard:ORG rdf:parseType='Resource'>
         <vCard:Orgname>organization</vCard:Orgname>
       </vCard:ORG>

    Each of the separate data values family name, given name, email
    address, and organization can be set and retrieved via corresponding
    methods in the ModelCreator  class.  These methods are documented in
    more detail below.

    """

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ModelCreator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ModelCreator, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_ModelCreator
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(ModelCreator self) -> ModelCreator
        __init__(ModelCreator self, XMLNode creator) -> ModelCreator
        __init__(ModelCreator self, ModelCreator orig) -> ModelCreator


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ModelCreator( XMLNode creator)

        Creates a new ModelCreator from an XMLNode.

        Parameter 'creator' is the XMLNode from which to create the
        ModelCreator.

        ______________________________________________________________________
        Method variant with the following signature:

            ModelCreator()

        Creates a new ModelCreator object.

        ______________________________________________________________________
        Method variant with the following signature:

            ModelCreator(ModelCreator orig)

        Copy constructor; creates a copy of the ModelCreator.

        Parameter 'orig' is the object to copy.

        """
        this = _libsbml.new_ModelCreator(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ModelCreator self) -> ModelCreator


        Creates and returns a deep copy of this ModelCreator object.

        Returns the (deep) copy of this ModelCreator object.

        """
        return _libsbml.ModelCreator_clone(self)


    def getFamilyName(self):
        """
        getFamilyName(ModelCreator self) -> string


        Returns the 'family name' stored in this ModelCreator object.

        Returns the 'family name' portion of the ModelCreator object.

        """
        return _libsbml.ModelCreator_getFamilyName(self)


    def getGivenName(self):
        """
        getGivenName(ModelCreator self) -> string


        Returns the 'given name' stored in this ModelCreator object.

        Returns the 'given name' portion of the ModelCreator object.

        """
        return _libsbml.ModelCreator_getGivenName(self)


    def getEmail(self):
        """
        getEmail(ModelCreator self) -> string


        Returns the 'email' stored in this ModelCreator object.

        Returns email from the ModelCreator.

        """
        return _libsbml.ModelCreator_getEmail(self)


    def getOrganization(self):
        """
        getOrganization(ModelCreator self) -> string


        Returns the 'organization' stored in this ModelCreator object.

        Returns organization from the ModelCreator.

        """
        return _libsbml.ModelCreator_getOrganization(self)


    def getOrganisation(self):
        """
        getOrganisation(ModelCreator self) -> string


        (Alternate spelling) Returns the 'organization' stored in this
        ModelCreator object.

        Note: This function is an alias of getOrganization().

        Returns organization from the ModelCreator.

        See also getOrganization().

        """
        return _libsbml.ModelCreator_getOrganisation(self)


    def getName(self):
        """
        getName(ModelCreator self) -> string


        Returns the 'fn' stored in this ModelCreator object when using vCard4.

        Returns the 'fn' portion of the ModelCreator object.

        """
        return _libsbml.ModelCreator_getName(self)


    def isSetFamilyName(self):
        """
        isSetFamilyName(ModelCreator self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        ModelCreator's 'family name' part is set.

        Returns 'True' if the familyName of this ModelCreator is set, 'False'
        otherwise.

        """
        return _libsbml.ModelCreator_isSetFamilyName(self)


    def isSetGivenName(self):
        """
        isSetGivenName(ModelCreator self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        ModelCreator's 'given name' part is set.

        Returns 'True' if the givenName of this ModelCreator is set, 'False'
        otherwise.

        """
        return _libsbml.ModelCreator_isSetGivenName(self)


    def isSetEmail(self):
        """
        isSetEmail(ModelCreator self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        ModelCreator's 'email' part is set.

        Returns 'True' if the email of this ModelCreator is set, 'False'
        otherwise.

        """
        return _libsbml.ModelCreator_isSetEmail(self)


    def isSetOrganization(self):
        """
        isSetOrganization(ModelCreator self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        ModelCreator's 'organization' part is set.

        Returns 'True' if the organization of this ModelCreator is set,
        'False' otherwise.

        """
        return _libsbml.ModelCreator_isSetOrganization(self)


    def isSetOrganisation(self):
        """
        isSetOrganisation(ModelCreator self) -> bool


        (Alternate spelling) Predicate returning 'True' or 'False' depending
        on whether this ModelCreator's 'organization' part is set.

        Note: This function is an alias of isSetOrganization().

        Returns 'True' if the organization of this ModelCreator is set,
        'False' otherwise.

        See also isSetOrganization().

        """
        return _libsbml.ModelCreator_isSetOrganisation(self)


    def isSetName(self):
        """
        isSetName(ModelCreator self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        ModelCreator's 'fn' part is set (when using vCard4).

        Returns 'True' if the fn of this ModelCreator is set, 'False'
        otherwise.

        """
        return _libsbml.ModelCreator_isSetName(self)


    def setFamilyName(self, familyName):
        """
        setFamilyName(ModelCreator self, string familyName) -> int


        Sets the 'family name' portion of this ModelCreator object.

        Parameter 'familyName' is a string representing the familyName of the
        ModelCreator.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.ModelCreator_setFamilyName(self, familyName)


    def setGivenName(self, givenName):
        """
        setGivenName(ModelCreator self, string givenName) -> int


        Sets the 'given name' portion of this ModelCreator object.

        Parameter 'givenName' is a string representing the givenName of the
        ModelCreator.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.ModelCreator_setGivenName(self, givenName)


    def setEmail(self, email):
        """
        setEmail(ModelCreator self, string email) -> int


        Sets the 'email' portion of this ModelCreator object.

        Parameter 'email' is a string representing the email of the
        ModelCreator.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.ModelCreator_setEmail(self, email)


    def setOrganization(self, organization):
        """
        setOrganization(ModelCreator self, string organization) -> int


        Sets the 'organization' portion of this ModelCreator object.

        Parameter 'organization' is a string representing the organization of
        the  ModelCreator.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.ModelCreator_setOrganization(self, organization)


    def setOrganisation(self, organization):
        """
        setOrganisation(ModelCreator self, string organization) -> int


        (Alternate spelling) Sets the 'organization' portion of this
        ModelCreator object.

        Parameter 'organization' is a string representing the organization of
        the ModelCreator.

        Note: This function is an alias of setOrganization(string
        organization).

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        See also setOrganization().

        """
        return _libsbml.ModelCreator_setOrganisation(self, organization)


    def setName(self, name):
        """
        setName(ModelCreator self, string name) -> int


        Sets the 'fn' portion of this ModelCreator object (when using vCard4).

        Parameter 'name' is a string representing the fn of the ModelCreator.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.ModelCreator_setName(self, name)


    def unsetFamilyName(self):
        """
        unsetFamilyName(ModelCreator self) -> int


        Unsets the 'family name' portion of this ModelCreator object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.ModelCreator_unsetFamilyName(self)


    def unsetGivenName(self):
        """
        unsetGivenName(ModelCreator self) -> int


        Unsets the 'given name' portion of this ModelCreator object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.ModelCreator_unsetGivenName(self)


    def unsetEmail(self):
        """
        unsetEmail(ModelCreator self) -> int


        Unsets the 'email' portion of this ModelCreator object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.ModelCreator_unsetEmail(self)


    def unsetOrganization(self):
        """
        unsetOrganization(ModelCreator self) -> int


        Unsets the 'organization' portion of this ModelCreator object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.ModelCreator_unsetOrganization(self)


    def unsetOrganisation(self):
        """
        unsetOrganisation(ModelCreator self) -> int


        (Alternate spelling) Unsets the 'organization' portion of this
        ModelCreator object.

        Note: This function is an alias of unsetOrganization().

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also unsetOrganization().

        """
        return _libsbml.ModelCreator_unsetOrganisation(self)


    def unsetName(self):
        """
        unsetName(ModelCreator self) -> int


        Unsets the 'fn' portion of this ModelCreator object (when using
        vCard4).

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.ModelCreator_unsetName(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(ModelCreator self) -> bool


        Predicate returning 'True' if all the required elements for this
        ModelCreator object have been set.

        The only required elements for a ModelCreator object are the 'family
        name' and 'given name'.

        Returns a boolean value indicating whether all the required elements
        for this object have been defined.

        """
        return _libsbml.ModelCreator_hasRequiredAttributes(self)


    def hasBeenModified(self):
        """
        hasBeenModified(ModelCreator self) -> bool


        Internal implementation method.

        """
        return _libsbml.ModelCreator_hasBeenModified(self)


    def resetModifiedFlags(self):
        """
        resetModifiedFlags(ModelCreator self)


        Internal implementation method.

        """
        return _libsbml.ModelCreator_resetModifiedFlags(self)


    def usingFNVcard4(self):
        """
        usingFNVcard4(ModelCreator self) -> bool


        Internal implementation method.

        """
        return _libsbml.ModelCreator_usingFNVcard4(self)


    def usingSingleName(self):
        """
        usingSingleName(ModelCreator self) -> bool


        Internal implementation method.

        """
        return _libsbml.ModelCreator_usingSingleName(self)


    def setUseSingleName(self, flag):
        """
        setUseSingleName(ModelCreator self, bool flag)


        Internal implementation method.

        """
        return _libsbml.ModelCreator_setUseSingleName(self, flag)


    __metaclass__ = AutoProperty


    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

ModelCreator_swigregister = _libsbml.ModelCreator_swigregister
ModelCreator_swigregister(ModelCreator)

class ModelHistory(_object):
    """

    MIRIAM-compliant data about a model's history.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    The SBML specification beginning with Level 2 Version 2 defines a
    standard approach to recording optional model history and model
    creator information in a form that complies with MIRIAM ('Minimum
    Information Requested in the Annotation of biochemical Models', Nature
    Biotechnology, vol. 23, no. 12, Dec. 2005).  LibSBML provides the
    ModelHistory class as a convenient high-level interface for working
    with model history data.

    Model histories in SBML consist of one or more model creators, a
    single date of creation, and one or more modification dates. The
    overall XML form of this data takes the following form:

       <dc:creator>
         <rdf:Bag>
           <rdf:li rdf:parseType='Resource'>
             +++
             <vCard:N rdf:parseType='Resource'>
               <vCard:Family>family name</vCard:Family>
               <vCard:Given>given name</vCard:Given>
             </vCard:N>
             +++
             <vCard:EMAIL><span style='background-color: #bbb'>email address</vCard:EMAIL></span>
             +++
             <vCard:ORG rdf:parseType='Resource'>
              <vCard:Orgname><span style='background-color: #bbb'>organization name</vCard:Orgname></span>
             </vCard:ORG>
             +++
           </rdf:li>
           ...
         </rdf:Bag>
       </dc:creator>
       <dcterms:created rdf:parseType='Resource'>
         <dcterms:W3CDTF>creation date</dcterms:W3CDTF>
       </dcterms:created>
       <dcterms:modified rdf:parseType='Resource'>
         <dcterms:W3CDTF>modification date</dcterms:W3CDTF>
       </dcterms:modified>
       ...

    In the template above, the underlined portions are optional, the
    symbol +++ is a placeholder for either no content or valid XML content
    that is not defined by the annotation scheme, and the ellipses ... are
    placeholders for zero or more elements of the same form as the
    immediately preceding element.  The various placeholders for content,
    namely family name, given name, email address, organization, creation
    date, and modification date are data that can be filled in using the
    various methods on the ModelHistory class described below.

    See also ModelCreator, Date.

    """

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ModelHistory, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ModelHistory, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_ModelHistory
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(ModelHistory self) -> ModelHistory
        __init__(ModelHistory self, ModelHistory orig) -> ModelHistory


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ModelHistory(ModelHistory orig)

        Copy constructor; creates a copy of this ModelHistory object.

        Parameter 'orig' is the object to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            ModelHistory()

        Creates a new ModelHistory object.

        """
        this = _libsbml.new_ModelHistory(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ModelHistory self) -> ModelHistory


        Creates and returns a deep copy of this ModelHistory object.

        Returns the (deep) copy of this ModelHistory object.

        """
        return _libsbml.ModelHistory_clone(self)


    def getCreatedDate(self):
        """
        getCreatedDate(ModelHistory self) -> Date


        Returns the 'creation date' portion of this ModelHistory object.

        Returns a Date object representing the creation date stored in this
        ModelHistory object.

        """
        return _libsbml.ModelHistory_getCreatedDate(self)


    def isSetCreatedDate(self):
        """
        isSetCreatedDate(ModelHistory self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        ModelHistory's 'creation date' is set.

        Returns 'True' if the creation date value of this ModelHistory is set,
        'False' otherwise.

        """
        return _libsbml.ModelHistory_isSetCreatedDate(self)


    def isSetModifiedDate(self):
        """
        isSetModifiedDate(ModelHistory self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        ModelHistory's 'modified date' is set.

        Returns 'True' if the modification date value of this ModelHistory
        object is set, 'False' otherwise.

        """
        return _libsbml.ModelHistory_isSetModifiedDate(self)


    def setCreatedDate(self, date):
        """
        setCreatedDate(ModelHistory self, Date date) -> int


        Sets the creation date of this ModelHistory object.

        Parameter 'date' is a Date object representing the date to which the
        'created date' portion of this ModelHistory should be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_OBJECT

        """
        return _libsbml.ModelHistory_setCreatedDate(self, date)


    def setModifiedDate(self, date):
        """
        setModifiedDate(ModelHistory self, Date date) -> int


        Sets the modification date of this ModelHistory object.

        Parameter 'date' is a Date object representing the date to which the
        'modified date' portion of this ModelHistory should be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        """
        return _libsbml.ModelHistory_setModifiedDate(self, date)


    def addModifiedDate(self, date):
        """
        addModifiedDate(ModelHistory self, Date date) -> int


        Adds a copy of a Date object to the list of 'modified date' values
        stored in this ModelHistory object.

        In the MIRIAM format for annotations, there can be multiple
        modification dates.  The libSBML ModelHistory class supports this by
        storing a list of 'modified date' values.

        Parameter 'date' is a Date object representing the 'modified date'
        that should be added to this ModelHistory object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        """
        return _libsbml.ModelHistory_addModifiedDate(self, date)


    def getListModifiedDates(self):
      """
      getListModifiedDates(self) -> DateList

      Get the List of Date objects in this ModelHistory.

      Returns the DateList for this ModelHistory.


      """
      return _libsbml.ModelHistory_getListModifiedDates(self)



    def getModifiedDate(self, *args):
        """
        getModifiedDate(ModelHistory self) -> Date
        getModifiedDate(ModelHistory self, unsigned int n) -> Date


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getModifiedDate()

        Returns the 'modified date' portion of this ModelHistory object.

        Note that in the MIRIAM format for annotations, there can be multiple
        modification dates.  The libSBML ModelHistory class supports this by
        storing a list of 'modified date' values.  If this ModelHistory object
        contains more than one 'modified date' value in the list, this method
        will return the first one in the list.

        Returns a Date object representing the date of modification stored in
        this ModelHistory object.

        ______________________________________________________________________
        Method variant with the following signature:

            getModifiedDate(long n)

        Get the nth Date object in the list of 'modified date' values stored
        in this ModelHistory object.

        In the MIRIAM format for annotations, there can be multiple
        modification dates.  The libSBML ModelHistory class supports this by
        storing a list of 'modified date' values.

        Returns the nth Date in the list of ModifiedDates of this ModelHistory
        or 'None' if no such object exists.

        """
        return _libsbml.ModelHistory_getModifiedDate(self, *args)


    def getNumModifiedDates(self):
        """
        getNumModifiedDates(ModelHistory self) -> unsigned int


        Get the number of Date objects in this ModelHistory object's list of
        'modified dates'.

        In the MIRIAM format for annotations, there can be multiple
        modification dates.  The libSBML ModelHistory class supports this by
        storing a list of 'modified date' values.

        Returns the number of ModifiedDates in this ModelHistory.

        """
        return _libsbml.ModelHistory_getNumModifiedDates(self)


    def addCreator(self, mc):
        """
        addCreator(ModelHistory self, ModelCreator mc) -> int


        Adds a copy of a ModelCreator object to the list of 'model creator'
        values stored in this ModelHistory object.

        In the MIRIAM format for annotations, there can be multiple model
        creators.  The libSBML ModelHistory class supports this by storing a
        list of 'model creator' values.

        Parameter 'mc' is the ModelCreator to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.ModelHistory_addCreator(self, mc)


    def getListCreators(self):
      """
      getListCreators(self) -> ModelCreatorList

      Get the List of ModelCreator objects in this
      ModelHistory.

      Returns the ModelCreatorList for this ModelHistory.


      """
      return _libsbml.ModelHistory_getListCreators(self)



    def getCreator(self, n):
        """
        getCreator(ModelHistory self, unsigned int n) -> ModelCreator


        Get the nth ModelCreator object stored in this ModelHistory object.

        In the MIRIAM format for annotations, there can be multiple model
        creators.  The libSBML ModelHistory class supports this by storing a
        list of 'model creator' values.

        Returns the nth ModelCreator object or 'None' if no such object
        exists.

        """
        return _libsbml.ModelHistory_getCreator(self, n)


    def getNumCreators(self):
        """
        getNumCreators(ModelHistory self) -> unsigned int


        Get the number of ModelCreator objects stored in this ModelHistory
        object.

        In the MIRIAM format for annotations, there can be multiple model
        creators.  The libSBML ModelHistory class supports this by storing a
        list of 'model creator' values.

        Returns the number of ModelCreators objects.

        """
        return _libsbml.ModelHistory_getNumCreators(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(ModelHistory self) -> bool


        Predicate returning 'True' if all the required elements for this
        ModelHistory object have been set.

        The required elements for a ModelHistory object are 'created name',
        'modified date', and at least one 'model creator'.

        Returns a boolean value indicating whether all the required elements
        for this object have been defined.

        """
        return _libsbml.ModelHistory_hasRequiredAttributes(self)


    def hasBeenModified(self):
        """
        hasBeenModified(ModelHistory self) -> bool


        Internal implementation method.

        """
        return _libsbml.ModelHistory_hasBeenModified(self)


    def resetModifiedFlags(self):
        """
        resetModifiedFlags(ModelHistory self)


        Internal implementation method.

        """
        return _libsbml.ModelHistory_resetModifiedFlags(self)


    __metaclass__ = AutoProperty


    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

ModelHistory_swigregister = _libsbml.ModelHistory_swigregister
ModelHistory_swigregister(ModelHistory)

class RDFAnnotationParser(_object):
    """

    MIRIAM-compliant RDF annotation reader/writer.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    RDFAnnotationParser is a libSBML construct used as part of the
    libSBML support for annotations conforming to the guidelines specified
    by MIRIAM ('Minimum Information Requested in the Annotation of
    biochemical Models', Nature Biotechnology, vol. 23, no. 12, Dec.
    2005).  Section 6 of the SBML Level 2 and Level 3 specification
    documents defines a recommended way of encoding MIRIAM information
    using a subset of RDF (Resource Description Format).  The general
    scheme is as follows.  A set of RDF-based annotations attached to a
    given SBML <annotation> element are read by RDFAnnotationParser and
    converted into a list of CVTerm objects.  There are different versions
    of the main method,  and RDFAnnotationParser.parseRDFAnnotation(),
    used depending on whether the annotation in question concerns the
    MIRIAM model history or other MIRIAM resource annotations.  A special
    object class, ModelHistory, is used to make it easier to manipulate
    model history annotations.

    All of the methods on RDFAnnotationParser are static; the class exists
    only to encapsulate the annotation and CVTerm parsing and manipulation
    functionality.

    """

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RDFAnnotationParser, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RDFAnnotationParser, name)
    __repr__ = _swig_repr

    def createAnnotation():
        """
        createAnnotation() -> XMLNode


        Creates a blank annotation and returns its root XMLNode object.

        This creates a completely empty SBML <annotation> element.  It is not
        attached to any SBML element.  An example of how this might be used is
        illustrated in the following code fragment.  In this example, suppose
        that 'content' is an XMLNode object previously created, containing
        MIRIAM-style annotations, and that 'sbmlObject' is an SBML object
        derived from SBase (e.g., a Model, or a Species, or a Compartment,
        etc.).  Then:

          RDF     = RDFAnnotationParser.createRDFAnnotation() # Create XML structure.
          success = RDF.addChild(...content...)               # Put some content into it.
          ...                                                 # Check return code value.

          annot   = RDFAnnotationParser.createAnnotation()    # Create <annotation>.
          success = annot.addChild(RDF)                       # Put the annotation into it.
          ...                                                 # Check return code value.

          success = sbmlObject.setAnnotation(annot)           # Set object's annotation.
          ...                                                 # Check return code value.

        The SBML specification contains more information about the format of
        annotations.  We urge readers to consult Section 6 of the SBML Level 2
        (Versions 2-4) and SBML Level 3 specification documents.

        Returns a pointer to an XMLNode for the annotation.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        See also RDFAnnotationParser.createRDFAnnotation() .

        """
        return _libsbml.RDFAnnotationParser_createAnnotation()

    createAnnotation = staticmethod(createAnnotation)

    def createRDFAnnotation(level=3, version=1):
        """
        createRDFAnnotation(unsigned int level=3, unsigned int version=1) -> XMLNode
        createRDFAnnotation(unsigned int level=3) -> XMLNode
        createRDFAnnotation() -> XMLNode


        Creates a blank RDF element suitable for use in SBML annotations.

        The annotation created by this method has namespace declarations for
        all the relevant XML namespaces used in RDF annotations and also has
        an empty RDF element.  The result is the following XML:

          <rdf:RDF xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#'
                   xmlns:dc='http://purl.org/dc/elements/1.1/'
                   xmlns:dcterms='http://purl.org/dc/terms/'
                   xmlns:vCard='http://www.w3.org/2001/vcard-rdf/3.0#'
                   xmlns:bqbiol='http://biomodels.net/biology-qualifiers/'
                   xmlns:bqmodel='http://biomodels.net/model-qualifiers/' >

          </rdf:RDF>

        Note that this does not create the containing SBML <annotation>
        element; the method RDFAnnotationParser.createAnnotation() is
        available for creating the container.

        Returns a pointer to an XMLNode.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        See also RDFAnnotationParser.createAnnotation() .

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        return _libsbml.RDFAnnotationParser_createRDFAnnotation(level, version)

    createRDFAnnotation = staticmethod(createRDFAnnotation)

    def createCVTerms(obj):
        """
        createCVTerms(SBase obj) -> XMLNode


        Takes a list of CVTerm objects and creates a the RDF 'Description'
        element.

        This essentially takes the given SBML object, reads out the CVTerm
        objects attached to it, creates an RDF 'Description' element to hold
        the terms, and adds each term with appropriate qualifiers.

        Parameter 'obj' is the SBML object to start from.

        Returns the XMLNode tree corresponding to the Description element of
        an RDF annotation.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.RDFAnnotationParser_createCVTerms(obj)

    createCVTerms = staticmethod(createCVTerms)

    def parseCVTerms(obj):
        """
        parseCVTerms(SBase obj) -> XMLNode


        Takes a list of CVTerm objects and creates a complete SBML annotation
        around it.

        This essentially takes the given SBML object, reads out the CVTerm
        objects attached to it, calls
        RDFAnnotationParser.createRDFAnnotation() to create an RDF annotation
        to hold the terms, and finally calls
        RDFAnnotationParser.createAnnotation() to wrap the result as an SBML
        <annotation> element.

        Parameter 'obj' is the SBML object to start from.

        Returns the XMLNode tree corresponding to the annotation.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.RDFAnnotationParser_parseCVTerms(obj)

    parseCVTerms = staticmethod(parseCVTerms)

    def parseModelHistory(obj):
        """
        parseModelHistory(SBase obj) -> XMLNode


        Reads the model history and cvTerms stored in 'obj' and creates the
        XML structure for an SBML annotation representing that metadata if
        there is a model history stored in 'obj'.

        Parameter 'obj' is any SBase object.

        Returns the XMLNode corresponding to an annotation containing  MIRIAM-
        compliant model history and CV term information in RDF format.

        Note: If the object does not have a history element stored then 'None'
        is returned even if CVTerms are present.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.RDFAnnotationParser_parseModelHistory(obj)

    parseModelHistory = staticmethod(parseModelHistory)

    def parseOnlyModelHistory(obj):
        """
        parseOnlyModelHistory(SBase obj) -> XMLNode


        Reads the model history stored in 'obj' and creates the XML structure
        for an SBML annotation representing that history.

        Parameter 'obj' is any SBase object.

        Returns the XMLNode corresponding to an annotation containing  MIRIAM-
        compliant model history information in RDF format.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.RDFAnnotationParser_parseOnlyModelHistory(obj)

    parseOnlyModelHistory = staticmethod(parseOnlyModelHistory)

    def deleteRDFAnnotation(annotation):
        """
        deleteRDFAnnotation(XMLNode annotation) -> XMLNode


        Deletes any SBML MIRIAM RDF annotation found in the given XMLNode
        tree and returns any remaining annotation content.

        The name of the XMLNode given as parameter 'annotation' must be
        'annotation', or else this method returns 'None.'  The method will
        walk down the XML structure looking for elements that are in the RDF
        XML namespace, and remove them if they conform to the syntax of a
        History or CVTerm element.

        Parameter 'annotation' is the XMLNode tree within which the RDF
        annotation is to be found and deleted.

        Returns the XMLNode structure that is left after RDF annotations are
        deleted.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.RDFAnnotationParser_deleteRDFAnnotation(annotation)

    deleteRDFAnnotation = staticmethod(deleteRDFAnnotation)

    def deleteRDFHistoryAnnotation(annotation):
        """
        deleteRDFHistoryAnnotation(XMLNode annotation) -> XMLNode


        Deletes any SBML MIRIAM RDF 'History' annotation found in the given
        XMLNode tree and returns any remaining annotation content.

        The name of the XMLNode given as parameter 'annotation' must be
        'annotation', or else this method returns 'None.'  The method will
        walk down the XML structure looking for elements that are in the RDF
        XML namespace, and remove any that conform to the syntax of a History
        element.

        Parameter 'annotation' is the XMLNode tree within which the RDF
        annotation is to be found and deleted.

        Returns the XMLNode structure that is left after RDF annotations are
        deleted.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.RDFAnnotationParser_deleteRDFHistoryAnnotation(annotation)

    deleteRDFHistoryAnnotation = staticmethod(deleteRDFHistoryAnnotation)

    def deleteRDFCVTermAnnotation(annotation):
        """
        deleteRDFCVTermAnnotation(XMLNode annotation) -> XMLNode


        Deletes any SBML MIRIAM RDF 'CVTerm' annotation found in the given
        XMLNode tree and returns any remaining annotation content.

        The name of the XMLNode given as parameter 'annotation' must be
        'annotation', or else this method returns 'None.'  The method will
        walk down the XML structure looking for elements that are in the RDF
        XML namespace, and remove any that conform to the syntax of a CVTerm
        element.

        Parameter 'annotation' is the XMLNode tree within which the RDF
        annotation is to be found and deleted.

        Returns the XMLNode structure that is left after RDF annotations are
        deleted.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.RDFAnnotationParser_deleteRDFCVTermAnnotation(annotation)

    deleteRDFCVTermAnnotation = staticmethod(deleteRDFCVTermAnnotation)

    def parseRDFAnnotation(*args):
        """
        parseRDFAnnotation(XMLNode annotation, char const * metaId=None, XMLInputStream stream=None) -> ModelHistory
        parseRDFAnnotation(XMLNode annotation, char const * metaId=None) -> ModelHistory
        parseRDFAnnotation(XMLNode annotation) -> ModelHistory
        parseRDFAnnotation(XMLNode annotation, CVTermList CVTerms)
        parseRDFAnnotation(XMLNode annotation, CVTermList CVTerms, char const * metaId=None, XMLInputStream stream=None)
        parseRDFAnnotation(XMLNode annotation, CVTermList CVTerms, char const * metaId=None)


        Parses an annotation (given as an XMLNode tree) into a list of
        CVTerm objects.

        This is used to take an annotation that has been read into an SBML
        model, identify the RDF elements within it, and create a list of
        corresponding CVTerm (controlled vocabulary term) objects.

        @param annotation XMLNode containing the annotation.
        @param CVTerms list of CVTerm objects to be created.
        @param metaId optional metaId, if set only the RDF annotation for this metaId will be returned.
        @param stream optional XMLInputStream that facilitates error logging.

        @copydetails doc_note_static_methods

        @htmlinclude warn-default-args-in-docs.html

        """
        return _libsbml.RDFAnnotationParser_parseRDFAnnotation(*args)

    parseRDFAnnotation = staticmethod(parseRDFAnnotation)

    def __init__(self):
        """
        __init__(RDFAnnotationParser self) -> RDFAnnotationParser


        @internal

        """
        this = _libsbml.new_RDFAnnotationParser()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_RDFAnnotationParser
    __del__ = lambda self: None
RDFAnnotationParser_swigregister = _libsbml.RDFAnnotationParser_swigregister
RDFAnnotationParser_swigregister(RDFAnnotationParser)

def RDFAnnotationParser_createAnnotation():
    """
    RDFAnnotationParser_createAnnotation() -> XMLNode


    Creates a blank annotation and returns its root XMLNode object.

    This creates a completely empty SBML <annotation> element.  It is not
    attached to any SBML element.  An example of how this might be used is
    illustrated in the following code fragment.  In this example, suppose
    that 'content' is an XMLNode object previously created, containing
    MIRIAM-style annotations, and that 'sbmlObject' is an SBML object
    derived from SBase (e.g., a Model, or a Species, or a Compartment,
    etc.).  Then:

      RDF     = RDFAnnotationParser.createRDFAnnotation() # Create XML structure.
      success = RDF.addChild(...content...)               # Put some content into it.
      ...                                                 # Check return code value.

      annot   = RDFAnnotationParser.createAnnotation()    # Create <annotation>.
      success = annot.addChild(RDF)                       # Put the annotation into it.
      ...                                                 # Check return code value.

      success = sbmlObject.setAnnotation(annot)           # Set object's annotation.
      ...                                                 # Check return code value.

    The SBML specification contains more information about the format of
    annotations.  We urge readers to consult Section 6 of the SBML Level 2
    (Versions 2-4) and SBML Level 3 specification documents.

    Returns a pointer to an XMLNode for the annotation.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    See also RDFAnnotationParser.createRDFAnnotation() .

    """
    return _libsbml.RDFAnnotationParser_createAnnotation()

def RDFAnnotationParser_createRDFAnnotation(level=3, version=1):
    """
    createRDFAnnotation(unsigned int level=3, unsigned int version=1) -> XMLNode
    createRDFAnnotation(unsigned int level=3) -> XMLNode
    RDFAnnotationParser_createRDFAnnotation() -> XMLNode


    Creates a blank RDF element suitable for use in SBML annotations.

    The annotation created by this method has namespace declarations for
    all the relevant XML namespaces used in RDF annotations and also has
    an empty RDF element.  The result is the following XML:

      <rdf:RDF xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#'
               xmlns:dc='http://purl.org/dc/elements/1.1/'
               xmlns:dcterms='http://purl.org/dc/terms/'
               xmlns:vCard='http://www.w3.org/2001/vcard-rdf/3.0#'
               xmlns:bqbiol='http://biomodels.net/biology-qualifiers/'
               xmlns:bqmodel='http://biomodels.net/model-qualifiers/' >

      </rdf:RDF>

    Note that this does not create the containing SBML <annotation>
    element; the method RDFAnnotationParser.createAnnotation() is
    available for creating the container.

    Returns a pointer to an XMLNode.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    See also RDFAnnotationParser.createAnnotation() .

    Note: Owing to the way that language interfaces are created in
    libSBML, this documentation may show methods that define default
    values for parameters with text that has the form parameter = value.
    This is not to be intepreted as a Python keyword argument; the use of
    a parameter name followed by an equals sign followed by a value is
    only meant to indicate a default value if the argument is not provided
    at all.  It is not a keyword in the Python sense.

    """
    return _libsbml.RDFAnnotationParser_createRDFAnnotation(level, version)

def RDFAnnotationParser_createCVTerms(obj):
    """
    RDFAnnotationParser_createCVTerms(SBase obj) -> XMLNode


    Takes a list of CVTerm objects and creates a the RDF 'Description'
    element.

    This essentially takes the given SBML object, reads out the CVTerm
    objects attached to it, creates an RDF 'Description' element to hold
    the terms, and adds each term with appropriate qualifiers.

    Parameter 'obj' is the SBML object to start from.

    Returns the XMLNode tree corresponding to the Description element of
    an RDF annotation.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.RDFAnnotationParser_createCVTerms(obj)

def RDFAnnotationParser_parseCVTerms(obj):
    """
    RDFAnnotationParser_parseCVTerms(SBase obj) -> XMLNode


    Takes a list of CVTerm objects and creates a complete SBML annotation
    around it.

    This essentially takes the given SBML object, reads out the CVTerm
    objects attached to it, calls
    RDFAnnotationParser.createRDFAnnotation() to create an RDF annotation
    to hold the terms, and finally calls
    RDFAnnotationParser.createAnnotation() to wrap the result as an SBML
    <annotation> element.

    Parameter 'obj' is the SBML object to start from.

    Returns the XMLNode tree corresponding to the annotation.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.RDFAnnotationParser_parseCVTerms(obj)

def RDFAnnotationParser_parseModelHistory(obj):
    """
    RDFAnnotationParser_parseModelHistory(SBase obj) -> XMLNode


    Reads the model history and cvTerms stored in 'obj' and creates the
    XML structure for an SBML annotation representing that metadata if
    there is a model history stored in 'obj'.

    Parameter 'obj' is any SBase object.

    Returns the XMLNode corresponding to an annotation containing  MIRIAM-
    compliant model history and CV term information in RDF format.

    Note: If the object does not have a history element stored then 'None'
    is returned even if CVTerms are present.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.RDFAnnotationParser_parseModelHistory(obj)

def RDFAnnotationParser_parseOnlyModelHistory(obj):
    """
    RDFAnnotationParser_parseOnlyModelHistory(SBase obj) -> XMLNode


    Reads the model history stored in 'obj' and creates the XML structure
    for an SBML annotation representing that history.

    Parameter 'obj' is any SBase object.

    Returns the XMLNode corresponding to an annotation containing  MIRIAM-
    compliant model history information in RDF format.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.RDFAnnotationParser_parseOnlyModelHistory(obj)

def RDFAnnotationParser_deleteRDFAnnotation(annotation):
    """
    RDFAnnotationParser_deleteRDFAnnotation(XMLNode annotation) -> XMLNode


    Deletes any SBML MIRIAM RDF annotation found in the given XMLNode
    tree and returns any remaining annotation content.

    The name of the XMLNode given as parameter 'annotation' must be
    'annotation', or else this method returns 'None.'  The method will
    walk down the XML structure looking for elements that are in the RDF
    XML namespace, and remove them if they conform to the syntax of a
    History or CVTerm element.

    Parameter 'annotation' is the XMLNode tree within which the RDF
    annotation is to be found and deleted.

    Returns the XMLNode structure that is left after RDF annotations are
    deleted.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.RDFAnnotationParser_deleteRDFAnnotation(annotation)

def RDFAnnotationParser_deleteRDFHistoryAnnotation(annotation):
    """
    RDFAnnotationParser_deleteRDFHistoryAnnotation(XMLNode annotation) -> XMLNode


    Deletes any SBML MIRIAM RDF 'History' annotation found in the given
    XMLNode tree and returns any remaining annotation content.

    The name of the XMLNode given as parameter 'annotation' must be
    'annotation', or else this method returns 'None.'  The method will
    walk down the XML structure looking for elements that are in the RDF
    XML namespace, and remove any that conform to the syntax of a History
    element.

    Parameter 'annotation' is the XMLNode tree within which the RDF
    annotation is to be found and deleted.

    Returns the XMLNode structure that is left after RDF annotations are
    deleted.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.RDFAnnotationParser_deleteRDFHistoryAnnotation(annotation)

def RDFAnnotationParser_deleteRDFCVTermAnnotation(annotation):
    """
    RDFAnnotationParser_deleteRDFCVTermAnnotation(XMLNode annotation) -> XMLNode


    Deletes any SBML MIRIAM RDF 'CVTerm' annotation found in the given
    XMLNode tree and returns any remaining annotation content.

    The name of the XMLNode given as parameter 'annotation' must be
    'annotation', or else this method returns 'None.'  The method will
    walk down the XML structure looking for elements that are in the RDF
    XML namespace, and remove any that conform to the syntax of a CVTerm
    element.

    Parameter 'annotation' is the XMLNode tree within which the RDF
    annotation is to be found and deleted.

    Returns the XMLNode structure that is left after RDF annotations are
    deleted.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.RDFAnnotationParser_deleteRDFCVTermAnnotation(annotation)

def RDFAnnotationParser_parseRDFAnnotation(*args):
    """
    parseRDFAnnotation(XMLNode annotation, char const * metaId=None, XMLInputStream stream=None) -> ModelHistory
    parseRDFAnnotation(XMLNode annotation, char const * metaId=None) -> ModelHistory
    parseRDFAnnotation(XMLNode annotation) -> ModelHistory
    parseRDFAnnotation(XMLNode annotation, CVTermList CVTerms)
    parseRDFAnnotation(XMLNode annotation, CVTermList CVTerms, char const * metaId=None, XMLInputStream stream=None)
    RDFAnnotationParser_parseRDFAnnotation(XMLNode annotation, CVTermList CVTerms, char const * metaId=None)


    Parses an annotation (given as an XMLNode tree) into a list of
    CVTerm objects.

    This is used to take an annotation that has been read into an SBML
    model, identify the RDF elements within it, and create a list of
    corresponding CVTerm (controlled vocabulary term) objects.

    @param annotation XMLNode containing the annotation.
    @param CVTerms list of CVTerm objects to be created.
    @param metaId optional metaId, if set only the RDF annotation for this metaId will be returned.
    @param stream optional XMLInputStream that facilitates error logging.

    @copydetails doc_note_static_methods

    @htmlinclude warn-default-args-in-docs.html

    """
    return _libsbml.RDFAnnotationParser_parseRDFAnnotation(*args)

class ISBMLExtensionNamespaces(SBMLNamespaces):
    """

    Internal implementation method.

    """

    __swig_setmethods__ = {}
    for _s in [SBMLNamespaces]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ISBMLExtensionNamespaces, name, value)
    __swig_getmethods__ = {}
    for _s in [SBMLNamespaces]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ISBMLExtensionNamespaces, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_ISBMLExtensionNamespaces
    __del__ = lambda self: None

    def getURI(self):
        """
        getURI(ISBMLExtensionNamespaces self) -> string


        Returns a string representing the SBML XML namespace of this object.

        Returns a string representing the SBML namespace that reflects the
        SBML Level and Version of this object.

        """
        return _libsbml.ISBMLExtensionNamespaces_getURI(self)


    def getPackageVersion(self):
        """getPackageVersion(ISBMLExtensionNamespaces self) -> unsigned int"""
        return _libsbml.ISBMLExtensionNamespaces_getPackageVersion(self)


    def getPackageName(self):
        """
        getPackageName(ISBMLExtensionNamespaces self) -> string


        Returns the name of the main package for this namespace.

        Returns the name of the main package for this namespace. 'core' will
        be returned if this namespace is defined in the SBML  core.

        """
        return _libsbml.ISBMLExtensionNamespaces_getPackageName(self)


    def setPackageVersion(self, pkgVersion):
        """setPackageVersion(ISBMLExtensionNamespaces self, unsigned int pkgVersion)"""
        return _libsbml.ISBMLExtensionNamespaces_setPackageVersion(self, pkgVersion)

ISBMLExtensionNamespaces_swigregister = _libsbml.ISBMLExtensionNamespaces_swigregister
ISBMLExtensionNamespaces_swigregister(ISBMLExtensionNamespaces)

class SBaseExtensionPoint(_object):
    """

    Internal implementation method.

    """

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SBaseExtensionPoint, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SBaseExtensionPoint, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_SBaseExtensionPoint
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(SBaseExtensionPoint self, string pkgName, int typeCode) -> SBaseExtensionPoint
        __init__(SBaseExtensionPoint self, string pkgName, int typeCode, string elementName, bool elementOnly=False) -> SBaseExtensionPoint
        __init__(SBaseExtensionPoint self, string pkgName, int typeCode, string elementName) -> SBaseExtensionPoint
        __init__(SBaseExtensionPoint self, SBaseExtensionPoint rhs) -> SBaseExtensionPoint


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            SBaseExtensionPoint(string pkgName, int typeCode, string
        elementName, bool elementOnly = false)

        Constructor for SBaseExtensionPoint.

        The use of SBaseExtensionPoint is relatively straightforward.  The
        class needs to be used for each extended SBML object implemented using
        SBMLDocumentPlugin or SBasePlugin.  Doing so requires knowing just two
        things:

        * The short-form name of the parent package being extended. The
        parent package is often simply core SBML, identified in libSBML by the
        nickname 'core', but a SBML Level 3 package could conceivably extend
        another Level 3 package and the mechanism supports this.

        * The libSBML type code assigned to the object being extended. For
        example, if an extension of Model is implemented, the relevant type
        code is SBML_MODEL, found in #SBMLTypeCode_t.

        Parameter 'pkgName' is the short-form name of the parent package where
        that this package extension is extending.

        Parameter 'typeCode' is the type code of the object being extended.

        Parameter 'elementName' is element name for the target element, in
        case  multiple elements match the same type code (as will be the case
        for ListOf classes).

        Parameter 'elementOnly' is flag to be used during the registration  of
        the package, when set then the plugin is only applied to  elements
        whose elementName match.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            SBaseExtensionPoint( SBaseExtensionPoint rhs)

        Copy constructor.

        This creates a copy of an SBaseExtensionPoint instance.

        Parameter 'rhs' is the object to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            SBaseExtensionPoint(string pkgName, int typeCode)

        Constructor for SBaseExtensionPoint.

        The use of SBaseExtensionPoint is relatively straightforward.  The
        class needs to be used for each extended SBML object implemented using
        SBMLDocumentPlugin or SBasePlugin.  Doing so requires knowing just two
        things:

        * The short-form name of the parent package being extended. The
        parent package is often simply core SBML, identified in libSBML by the
        nickname 'core', but a SBML Level 3 package could conceivably extend
        another Level 3 package and the mechanism supports this.

        * The libSBML type code assigned to the object being extended. For
        example, if an extension of Model is implemented, the relevant type
        code is SBML_MODEL, found in #SBMLTypeCode_t.

        Parameter 'pkgName' is the short-form name of the parent package where
        that this package extension is extending.

        Parameter 'typeCode' is the type code of the object being extended.

        """
        this = _libsbml.new_SBaseExtensionPoint(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(SBaseExtensionPoint self) -> SBaseExtensionPoint


        Creates and returns a deep copy of this SBaseExtensionPoint object.

        Returns the (deep) copy of this SBaseExtensionPoint object.

        """
        return _libsbml.SBaseExtensionPoint_clone(self)


    def getPackageName(self):
        """
        getPackageName(SBaseExtensionPoint self) -> string


        Returns the package name of this extension point.

        """
        return _libsbml.SBaseExtensionPoint_getPackageName(self)


    def getTypeCode(self):
        """
        getTypeCode(SBaseExtensionPoint self) -> int


        Returns the libSBML type code of this extension point.

        """
        return _libsbml.SBaseExtensionPoint_getTypeCode(self)


    def getElementName(self):
        """
        getElementName(SBaseExtensionPoint self) -> string


        the target element name

        """
        return _libsbml.SBaseExtensionPoint_getElementName(self)


    def isElementOnly(self):
        """
        isElementOnly(SBaseExtensionPoint self) -> bool




        """
        return _libsbml.SBaseExtensionPoint_isElementOnly(self)

SBaseExtensionPoint_swigregister = _libsbml.SBaseExtensionPoint_swigregister
SBaseExtensionPoint_swigregister(SBaseExtensionPoint)

class SBasePlugin(_object):
    """

    Base class for extending SBML objects in packages.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    The SBasePlugin class is libSBML's base class for extensions of core
    SBML component objects.  SBasePlugin defines basic virtual methods for
    reading/writing/checking additional attributes and/or subobjects;
    these methods should be overridden by subclasses to implement the
    necessary features of an extended SBML object.

    Basic principles of SBML package extensions in libSBML
    ======================================================================

    SBML Level 3's package structure permits modular extensions to the
    core SBML format.  In libSBML, support for SBML Level 3 packages is
    provided through optional package extensions that can be plugged into
    libSBML at the time it is built/compiled.  Users of libSBML can thus
    choose which extensions are enabled in their software applications.

    LibSBML defines a number of classes that developers of package
    extensions can use to implement support for an SBML Level 3 package.
    These classes make it easier to extend libSBML objects with new
    attributes and/or subobjects as needed by a particular Level 3
    package. Three overall categories of classes make up libSBML's
    facilities for implementing package extensions.  There are (1) classes
    that serve as base classes meant to be subclassed, (2) template
    classes meant to be instantiated rather than subclassed, and (3)
    support classes that provide utility features. A given package
    implementation for libSBML will take the form of code using these and
    other libSBML classes, placed in a subdirectory of src/sbml/packages/.

    The basic libSBML distribution includes a number of package extensions
    implementing support for officially-endorsed SBML Level 3 packages;
    among these are Flux Balance Constraints ('fbc'), Hierarchical Model
    Composition ('comp'), Layout ('layout'), and Qualitative Models
    ('qual').  They can serve as working examples for developers working
    to implement other packages.

    Extensions in libSBML can currently only be implemented in C++ or C;
    there is no mechanism to implement them first in languages such as
    Java or Python.  However, once implemented in C++ or C, language
    interfaces can be generated semi-automatically using the framework in
    place in libSBML.  (The approach is based on using SWIG and facilities
    in libSBML's build system.)

    """

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SBasePlugin, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SBasePlugin, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_SBasePlugin
    __del__ = lambda self: None

    def getElementNamespace(self):
        """
        getElementNamespace(SBasePlugin self) -> string


        Returns the namespace URI of the package to which this plugin object
        belongs.

        Returns the XML namespace URI of the SBML Level 3 package implemented
        by this libSBML package extension.

        """
        return _libsbml.SBasePlugin_getElementNamespace(self)


    def getPrefix(self):
        """
        getPrefix(SBasePlugin self) -> string


        Returns the XML namespace prefix of the package to which this plugin
        object belongs.

        Returns the XML namespace prefix of the SBML Level 3 package
        implemented by this libSBML package extension.

        """
        return _libsbml.SBasePlugin_getPrefix(self)


    def getPackageName(self):
        """
        getPackageName(SBasePlugin self) -> string


        Returns the short-form name of the package to which this plugin object
        belongs.

        Returns the short-form package name (or nickname) of the SBML package
        implemented by this package extension.

        """
        return _libsbml.SBasePlugin_getPackageName(self)


    def clone(self):
        """
        clone(SBasePlugin self) -> SBasePlugin


        Creates and returns a deep copy of this SBasePlugin object.

        Returns the (deep) copy of this SBasePlugin object.

        """
        return _libsbml.SBasePlugin_clone(self)


    def getElementBySId(self, id):
        """
        getElementBySId(SBasePlugin self, string id) -> SBase


        Return the first child object found with a given identifier.

        This method searches all the subobjects under this one, compares their
        identifiers to 'id', and returns the first one that machines.

        Normally, SId type identifier values are unique across a model in
        SBML.  However, in some circumstances they may not be, such as if a
        model is invalid because of multiple objects having the same
        identifier.

        Parameter 'id' is string representing the identifier of the object to
        find.

        Returns pointer to the first object with the given 'id'.

        """
        return _libsbml.SBasePlugin_getElementBySId(self, id)


    def getElementByMetaId(self, metaid):
        """
        getElementByMetaId(SBasePlugin self, string metaid) -> SBase


        Return the first child object found with a given meta identifier.

        This method searches all the subobjects under this one, compares their
        meta identifiers to 'metaid', and returns the first one that machines.

        Parameter 'metaid' is string, the metaid of the object to find.

        Returns pointer to the first object found with the given 'metaid'.

        """
        return _libsbml.SBasePlugin_getElementByMetaId(self, metaid)


    def connectToParent(self, sbase):
        """
        connectToParent(SBasePlugin self, SBase sbase)


        Internal implementation method.

        """
        return _libsbml.SBasePlugin_connectToParent(self, sbase)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(SBasePlugin self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.SBasePlugin_enablePackageInternal(self, pkgURI, pkgPrefix, flag)


    def stripPackage(self, pkgPrefix, flag):
        """
        stripPackage(SBasePlugin self, string pkgPrefix, bool flag) -> bool


        Internal implementation method.

        """
        return _libsbml.SBasePlugin_stripPackage(self, pkgPrefix, flag)


    def getSBMLDocument(self, *args):
        """
        getSBMLDocument(SBasePlugin self) -> SBMLDocument
        getSBMLDocument(SBasePlugin self) -> SBMLDocument


        Returns the SBMLDocument object containing this object instance.

        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
        SBML defined in the SBML Level 3 and Level 2 specifications, but it
        does not have a direct correspondence in SBML Level 1.  (But, it is
        created by libSBML no matter whether the model is Level 1, Level 2 or
        Level 3.)

        This method allows the caller to obtain the SBMLDocument for the
        current object.

        Returns the parent SBMLDocument object of this plugin object.

        See also getParentSBMLObject().

        """
        return _libsbml.SBasePlugin_getSBMLDocument(self, *args)


    def getURI(self):
        """
        getURI(SBasePlugin self) -> string


        Returns the XML namespace URI for the package to which this object
        belongs.

        In the XML representation of an SBML document, XML namespaces are
        used to identify the origin of each XML construct used.  XML
        namespaces are identified by their unique resource identifiers (URIs).
        The core SBML specifications stipulate the namespaces that must be
        used for core SBML constructs; for example, all XML elements that
        belong to SBML Level 3 Version 1 Core must be placed in the XML
        namespace identified by the URI
        'http://www.sbml.org/sbml/level3/version1/core'.  Individual SBML
        Level 3 packages define their own XML namespaces; for example, all
        elements belonging to the SBML Level 3 Layout Version 1 package must
        be placed in the XML namespace
        'http://www.sbml.org/sbml/level3/version1/layout/version1/'.

        This method first looks into the SBMLNamespaces object possessed by
        the parent SBMLDocument object of the current object.  If this cannot
        be found, this method returns the result of getElementNamespace().

        Returns a string, the URI of the XML namespace to which this object
        belongs.

        See also getPackageName(), getElementNamespace(), getSBMLDocument().

        """
        return _libsbml.SBasePlugin_getURI(self)


    def getParentSBMLObject(self, *args):
        """
        getParentSBMLObject(SBasePlugin self) -> SBase
        getParentSBMLObject(SBasePlugin self) -> SBase


        Returns the parent object to which this plugin object is connected.

        Returns the parent object of this object.

        """
        return _libsbml.SBasePlugin_getParentSBMLObject(self, *args)


    def setElementNamespace(self, uri):
        """
        setElementNamespace(SBasePlugin self, string uri) -> int


        Sets the XML namespace to which this object belongs.

        In the XML representation of an SBML document, XML namespaces are
        used to identify the origin of each XML construct used.  XML
        namespaces are identified by their unique resource identifiers (URIs).
        The core SBML specifications stipulate the namespaces that must be
        used for core SBML constructs; for example, all XML elements that
        belong to SBML Level 3 Version 1 Core must be placed in the XML
        namespace identified by the URI
        'http://www.sbml.org/sbml/level3/version1/core'.  Individual SBML
        Level 3 packages define their own XML namespaces; for example, all
        elements belonging to the SBML Level 3 Layout Version 1 package must
        be placed in the XML namespace
        'http://www.sbml.org/sbml/level3/version1/layout/version1/'.

        Parameter 'uri' is the URI to assign to this object.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        See also getElementNamespace().

        """
        return _libsbml.SBasePlugin_setElementNamespace(self, uri)


    def getLevel(self):
        """
        getLevel(SBasePlugin self) -> unsigned int


        Returns the SBML Level of the package extension of this plugin object.

        Returns the SBML Level.

        See also getVersion().

        """
        return _libsbml.SBasePlugin_getLevel(self)


    def getVersion(self):
        """
        getVersion(SBasePlugin self) -> unsigned int


        Returns the Version within the SBML Level of the package extension of
        this plugin object.

        Returns the SBML Version.

        See also getLevel().

        """
        return _libsbml.SBasePlugin_getVersion(self)


    def getPackageVersion(self):
        """
        getPackageVersion(SBasePlugin self) -> unsigned int


        Returns the package version of the package extension of this plugin
        object.

        Returns the package version of the package extension of this plugin
        object.

        See also getLevel(), getVersion().

        """
        return _libsbml.SBasePlugin_getPackageVersion(self)


    def replaceSIDWithFunction(self, id, function):
        """
        replaceSIDWithFunction(SBasePlugin self, string id, ASTNode function)


        Internal implementation method.

        """
        return _libsbml.SBasePlugin_replaceSIDWithFunction(self, id, function)


    def divideAssignmentsToSIdByFunction(self, id, function):
        """
        divideAssignmentsToSIdByFunction(SBasePlugin self, string id, ASTNode function)


        Internal implementation method.

        """
        return _libsbml.SBasePlugin_divideAssignmentsToSIdByFunction(self, id, function)


    def multiplyAssignmentsToSIdByFunction(self, id, function):
        """
        multiplyAssignmentsToSIdByFunction(SBasePlugin self, string id, ASTNode function)


        Internal implementation method.

        """
        return _libsbml.SBasePlugin_multiplyAssignmentsToSIdByFunction(self, id, function)


    def hasIdentifierBeginningWith(self, prefix):
        """
        hasIdentifierBeginningWith(SBasePlugin self, string prefix) -> bool


        Internal implementation method.

        """
        return _libsbml.SBasePlugin_hasIdentifierBeginningWith(self, prefix)


    def prependStringToAllIdentifiers(self, prefix):
        """
        prependStringToAllIdentifiers(SBasePlugin self, string prefix) -> int


        Internal implementation method.

        """
        return _libsbml.SBasePlugin_prependStringToAllIdentifiers(self, prefix)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(SBasePlugin self, string oldid, string newid)


        Replaces all uses of a given 'SIdRef' type attribute value with
        another value.

        In SBML, object identifiers are of a data type called SId. In SBML
        Level 3, an explicit data type called SIdRef was introduced for
        attribute values that refer to SId values; in previous Levels of SBML,
        this data type did not exist and attributes were simply described to
        as 'referring to an identifier', but the effective data type was the
        same as SIdRef in Level 3.  These and other methods of libSBML refer
        to the type SIdRef for all Levels of SBML, even if the corresponding
        SBML specification did not explicitly name the data type.

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas in MathML content, comparing the referenced
        identifiers to the value of 'oldid'.  If any matches are found, the
        matching values are replaced with 'newid'.  The method does not
        descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.SBasePlugin_renameSIdRefs(self, oldid, newid)


    def renameMetaIdRefs(self, oldid, newid):
        """
        renameMetaIdRefs(SBasePlugin self, string oldid, string newid)


        Replaces all uses of a given meta identifier attribute value with
        another value.

        In SBML, object 'meta' identifiers are of the XML data type ID; the
        SBML object attribute itself is typically named metaid.  All
        attributes that hold values referring to values of type ID are of the
        XML data type IDREF.  They are also sometimes informally referred to
        as 'metaid refs', in analogy to the SBML-defined type SIdRef.

        This method works by looking at all meta-identifier attribute values,
        comparing the identifiers to the value of 'oldid'.  If any matches are
        found, the matching identifiers are replaced with 'newid'.  The method
        does not descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.SBasePlugin_renameMetaIdRefs(self, oldid, newid)


    def renameUnitSIdRefs(self, oldid, newid):
        """
        renameUnitSIdRefs(SBasePlugin self, string oldid, string newid)


        Replaces all uses of a given 'UnitSIdRef' type attribute value with
        another value.

        In SBML, unit definitions have identifiers of type UnitSId.  In SBML
        Level 3, an explicit data type called UnitSIdRef was introduced for
        attribute values that refer to UnitSId values; in previous Levels of
        SBML, this data type did not exist and attributes were simply
        described to as 'referring to a unit identifier', but the effective
        data type was the same as UnitSIdRef in Level 3.  These and other
        methods of libSBML refer to the type UnitSIdRef for all Levels of
        SBML, even if the corresponding SBML specification did not explicitly
        name the data type.

        This method works by looking at all unit identifier attribute values
        (including, if appropriate, inside mathematical formulas), comparing
        the referenced unit identifiers to the value of 'oldid'.  If any
        matches are found, the matching values are replaced with 'newid'.  The
        method does not descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.SBasePlugin_renameUnitSIdRefs(self, oldid, newid)


    def transformIdentifiers(self, sidTransformer):
        """
        transformIdentifiers(SBasePlugin self, IdentifierTransformer sidTransformer) -> int


        Internal implementation method.

        """
        return _libsbml.SBasePlugin_transformIdentifiers(self, sidTransformer)


    def getLine(self):
        """
        getLine(SBasePlugin self) -> unsigned int


        Internal implementation method.

        """
        return _libsbml.SBasePlugin_getLine(self)


    def getColumn(self):
        """
        getColumn(SBasePlugin self) -> unsigned int


        Internal implementation method.

        """
        return _libsbml.SBasePlugin_getColumn(self)


    def getSBMLNamespaces(self):
        """
        getSBMLNamespaces(SBasePlugin self) -> SBMLNamespaces


        Internal implementation method.

        """
        return _libsbml.SBasePlugin_getSBMLNamespaces(self)


    def logUnknownElement(self, element, sbmlLevel, sbmlVersion, pkgVersion):
        """
        logUnknownElement(SBasePlugin self, string element, unsigned int const sbmlLevel, unsigned int const sbmlVersion, unsigned int const pkgVersion)


        Internal implementation method.

        """
        return _libsbml.SBasePlugin_logUnknownElement(self, element, sbmlLevel, sbmlVersion, pkgVersion)


    def isValidTypeForList(self, item):
        """
        isValidTypeForList(SBasePlugin self, SBase item) -> bool




        """
        return _libsbml.SBasePlugin_isValidTypeForList(self, item)


    def getSBMLExtension(self):
        """
        getSBMLExtension(SBasePlugin self) -> SBMLExtension


        Internal implementation method.

        """
        return _libsbml.SBasePlugin_getSBMLExtension(self)


    def updateSBMLNamespace(self, package, level, version):
        """
        updateSBMLNamespace(SBasePlugin self, string package, unsigned int level, unsigned int version)


        Internal implementation method.

        """
        return _libsbml.SBasePlugin_updateSBMLNamespace(self, package, level, version)


    __metaclass__ = AutoProperty


    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


    def getListOfAllElements(self, *args):
      """
      getListOfAllElements(self) -> SBaseList

      Get the List of SBase objects in this plugin.

      Returns the SBaseList of all element for this plugin.


      """
      return _libsbml.SBasePlugin_getListOfAllElements(self, *args)


SBasePlugin_swigregister = _libsbml.SBasePlugin_swigregister
SBasePlugin_swigregister(SBasePlugin)

class SBMLDocumentPlugin(SBasePlugin):
    """

    Base class for extending SBMLDocument in packages.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    The SBMLDocumentPlugin class is a specialization of SBasePlugin
    designed specifically for extending SBMLDocument.  All package
    extensions must extend SBMLDocument to implement support for SBML
    Level 3 packages; these extensions can be subclasses of this class or
    from a derived class of this class.

    All packages must additionally define a required flag named required,
    which indicates whether  that package's constructs can be used to
    change the core mathematics of the <model> child of the <sbml>
    element. If they can, this attribute must be set 'True,' and if they
    cannot, this  attribute must be set 'False.'

    Basic principles of SBML package extensions in libSBML
    ======================================================================

    SBML Level 3's package structure permits modular extensions to the
    core SBML format.  In libSBML, support for SBML Level 3 packages is
    provided through optional package extensions that can be plugged into
    libSBML at the time it is built/compiled.  Users of libSBML can thus
    choose which extensions are enabled in their software applications.

    LibSBML defines a number of classes that developers of package
    extensions can use to implement support for an SBML Level 3 package.
    These classes make it easier to extend libSBML objects with new
    attributes and/or subobjects as needed by a particular Level 3
    package. Three overall categories of classes make up libSBML's
    facilities for implementing package extensions.  There are (1) classes
    that serve as base classes meant to be subclassed, (2) template
    classes meant to be instantiated rather than subclassed, and (3)
    support classes that provide utility features. A given package
    implementation for libSBML will take the form of code using these and
    other libSBML classes, placed in a subdirectory of src/sbml/packages/.

    The basic libSBML distribution includes a number of package extensions
    implementing support for officially-endorsed SBML Level 3 packages;
    among these are Flux Balance Constraints ('fbc'), Hierarchical Model
    Composition ('comp'), Layout ('layout'), and Qualitative Models
    ('qual').  They can serve as working examples for developers working
    to implement other packages.

    Extensions in libSBML can currently only be implemented in C++ or C;
    there is no mechanism to implement them first in languages such as
    Java or Python.  However, once implemented in C++ or C, language
    interfaces can be generated semi-automatically using the framework in
    place in libSBML.  (The approach is based on using SWIG and facilities
    in libSBML's build system.)

    """

    __swig_setmethods__ = {}
    for _s in [SBasePlugin]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLDocumentPlugin, name, value)
    __swig_getmethods__ = {}
    for _s in [SBasePlugin]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SBMLDocumentPlugin, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(SBMLDocumentPlugin self, string uri, string prefix, SBMLNamespaces sbmlns) -> SBMLDocumentPlugin
        __init__(SBMLDocumentPlugin self, SBMLDocumentPlugin orig) -> SBMLDocumentPlugin


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            SBMLDocumentPlugin(string &uri, string &prefix,
        SBMLNamespaces sbmlns)

        Creates a new SBMLDocumentPlugin object using the given parameters.

        In the XML representation of an SBML document, XML namespaces are
        used to identify the origin of each XML construct used.  XML
        namespaces are identified by their unique resource identifiers (URIs).
        The core SBML specifications stipulate the namespaces that must be
        used for core SBML constructs; for example, all XML elements that
        belong to SBML Level 3 Version 1 Core must be placed in the XML
        namespace identified by the URI
        'http://www.sbml.org/sbml/level3/version1/core'.  Individual SBML
        Level 3 packages define their own XML namespaces; for example, all
        elements belonging to the SBML Level 3 Layout Version 1 package must
        be placed in the XML namespace
        'http://www.sbml.org/sbml/level3/version1/layout/version1/'.

        The SBMLNamespaces object encapsulates SBML Level/Version/namespaces
        information.  It is used to communicate the SBML Level, Version, and
        (in Level 3) packages used in addition to SBML Level 3 Core.  A common
        approach to using libSBML's SBMLNamespaces facilities is to create an
        SBMLNamespaces object somewhere in a program once, then hand that
        object as needed to object constructors that accept SBMLNamespaces as
        arguments.

        Parameter 'uri' is the URI of the SBML Level 3 package implemented by
        this libSBML package extension.

        Parameter 'prefix' is the XML namespace prefix being used for the
        package.

        Parameter 'sbmlns' is the SBMLNamespaces object for the package.

        ______________________________________________________________________
        Method variant with the following signature:

            SBMLDocumentPlugin(SBMLDocumentPlugin orig)

        Copy constructor.

        This creates a copy of this object.

        Parameter 'orig' is the SBMLDocumentPlugin instance to copy.

        """
        this = _libsbml.new_SBMLDocumentPlugin(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_SBMLDocumentPlugin
    __del__ = lambda self: None

    def clone(self):
        """
        clone(SBMLDocumentPlugin self) -> SBMLDocumentPlugin


        Creates and returns a deep copy of this SBMLDocumentPlugin object.

        Returns the (deep) copy of this SBMLDocumentPlugin object.

        """
        return _libsbml.SBMLDocumentPlugin_clone(self)


    def setRequired(self, value):
        """
        setRequired(SBMLDocumentPlugin self, bool value) -> int


        Sets the SBML 'required' attribute value.

        SBML Level 3 requires that every package defines an attribute named
        'required' on the root <sbml> element in an SBML file or data stream.
        The attribute, being in the namespace of the Level 3 package in
        question, must be prefixed by the XML namespace prefix associated with
        the package.  The value of the 'required' attribute indicates whether
        constructs in that package may change the mathematical interpretation
        of constructs defined in SBML Level 3 Core.  A 'required' value of
        'True' indicates that the package may do so.  The value of the
        attribute is set by the Level 3 package specification, and does not
        depend on the actual presence or absence of particular package
        constructs in a given SBML document: in other words, if the package
        specification defines any construct that can change the model's
        meaning, the value of the 'required' attribute must always be set to
        'True' in any SBML document that uses the package.

        The XML namespace declaration for an SBML Level 3 package is an
        indication that a model makes use of features defined by that package,
        while the 'required' attribute indicates whether the features may be
        ignored without compromising the mathematical meaning of the model.
        Both are necessary for a complete reference to an SBML Level 3
        package.

        Parameter 'value' is the value to be assigned to the 'required'
        attribute. The 'required' attribute takes a Boolean value, either
        'True' or 'False.'

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        See also getRequired(), isSetRequired(), unsetRequired().

        """
        return _libsbml.SBMLDocumentPlugin_setRequired(self, value)


    def getRequired(self):
        """
        getRequired(SBMLDocumentPlugin self) -> bool


        Returns the value of the 'required' attribute.

        SBML Level 3 requires that every package defines an attribute named
        'required' on the root <sbml> element in an SBML file or data stream.
        The attribute, being in the namespace of the Level 3 package in
        question, must be prefixed by the XML namespace prefix associated with
        the package.  The value of the 'required' attribute indicates whether
        constructs in that package may change the mathematical interpretation
        of constructs defined in SBML Level 3 Core.  A 'required' value of
        'True' indicates that the package may do so.  The value of the
        attribute is set by the Level 3 package specification, and does not
        depend on the actual presence or absence of particular package
        constructs in a given SBML document: in other words, if the package
        specification defines any construct that can change the model's
        meaning, the value of the 'required' attribute must always be set to
        'True' in any SBML document that uses the package.

        The XML namespace declaration for an SBML Level 3 package is an
        indication that a model makes use of features defined by that package,
        while the 'required' attribute indicates whether the features may be
        ignored without compromising the mathematical meaning of the model.
        Both are necessary for a complete reference to an SBML Level 3
        package.

        Returns the bool value of 'required' attribute for the SBML package.

        See also setRequired(), isSetRequired(), unsetRequired().

        """
        return _libsbml.SBMLDocumentPlugin_getRequired(self)


    def isSetRequired(self):
        """
        isSetRequired(SBMLDocumentPlugin self) -> bool


        Returns the value of the 'required' attribute.

        SBML Level 3 requires that every package defines an attribute named
        'required' on the root <sbml> element in an SBML file or data stream.
        The attribute, being in the namespace of the Level 3 package in
        question, must be prefixed by the XML namespace prefix associated with
        the package.  The value of the 'required' attribute indicates whether
        constructs in that package may change the mathematical interpretation
        of constructs defined in SBML Level 3 Core.  A 'required' value of
        'True' indicates that the package may do so.  The value of the
        attribute is set by the Level 3 package specification, and does not
        depend on the actual presence or absence of particular package
        constructs in a given SBML document: in other words, if the package
        specification defines any construct that can change the model's
        meaning, the value of the 'required' attribute must always be set to
        'True' in any SBML document that uses the package.

        The XML namespace declaration for an SBML Level 3 package is an
        indication that a model makes use of features defined by that package,
        while the 'required' attribute indicates whether the features may be
        ignored without compromising the mathematical meaning of the model.
        Both are necessary for a complete reference to an SBML Level 3
        package.

        Returns 'True' if the 'required' attribute of this SBMLDocument has
        been set to 'True,' 'False' otherwise.

        """
        return _libsbml.SBMLDocumentPlugin_isSetRequired(self)


    def unsetRequired(self):
        """
        unsetRequired(SBMLDocumentPlugin self) -> int


        Unsets the value of the 'required' attribute of this
        SBMLDocumentPlugin.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.SBMLDocumentPlugin_unsetRequired(self)


    def isCompFlatteningImplemented(self):
        """
        isCompFlatteningImplemented(SBMLDocumentPlugin self) -> bool


        Internal implementation method.

        """
        return _libsbml.SBMLDocumentPlugin_isCompFlatteningImplemented(self)


    def checkConsistency(self):
        """
        checkConsistency(SBMLDocumentPlugin self) -> unsigned int


        Internal implementation method.

        """
        return _libsbml.SBMLDocumentPlugin_checkConsistency(self)

SBMLDocumentPlugin_swigregister = _libsbml.SBMLDocumentPlugin_swigregister
SBMLDocumentPlugin_swigregister(SBMLDocumentPlugin)

class SBMLExtension(_object):
    """

    Base class for SBML Level 3 package plug-ins.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    The SBMLExtension class is a component of the libSBML package
    extension mechanism.  It is an abstract class that is extended by each
    package extension implementation.

    Basic principles of SBML package extensions in libSBML
    ======================================================================

    SBML Level 3's package structure permits modular extensions to the
    core SBML format.  In libSBML, support for SBML Level 3 packages is
    provided through optional package extensions that can be plugged into
    libSBML at the time it is built/compiled.  Users of libSBML can thus
    choose which extensions are enabled in their software applications.

    LibSBML defines a number of classes that developers of package
    extensions can use to implement support for an SBML Level 3 package.
    These classes make it easier to extend libSBML objects with new
    attributes and/or subobjects as needed by a particular Level 3
    package. Three overall categories of classes make up libSBML's
    facilities for implementing package extensions.  There are (1) classes
    that serve as base classes meant to be subclassed, (2) template
    classes meant to be instantiated rather than subclassed, and (3)
    support classes that provide utility features. A given package
    implementation for libSBML will take the form of code using these and
    other libSBML classes, placed in a subdirectory of src/sbml/packages/.

    The basic libSBML distribution includes a number of package extensions
    implementing support for officially-endorsed SBML Level 3 packages;
    among these are Flux Balance Constraints ('fbc'), Hierarchical Model
    Composition ('comp'), Layout ('layout'), and Qualitative Models
    ('qual').  They can serve as working examples for developers working
    to implement other packages.

    Extensions in libSBML can currently only be implemented in C++ or C;
    there is no mechanism to implement them first in languages such as
    Java or Python.  However, once implemented in C++ or C, language
    interfaces can be generated semi-automatically using the framework in
    place in libSBML.  (The approach is based on using SWIG and facilities
    in libSBML's build system.)

    Special handling for SBML Level 2
    ======================================================================

    Due to the historical background of the SBML Layout package, libSBML
    implements special behavior for that package: it always creates a
    Layout plugin object for any SBML Level 2 document it reads in,
    regardless of whether that document actually uses Layout constructs.
    This is unlike the case for SBML Level 3 documents that use Layout;
    for them, libSBML will not create a plugin object unless the document
    actually declares the use of the Layout package (via the usual Level 3
    namespace declaration for Level 3 packages).

    This has the following consequence.  If an application queries for the
    presence of Layout in an SBML Level 2 document by testing only for the
    existence of the plugin object, it will always get a positive result;
    in other words, the presence of a Layout extension object is not an
    indication of whether a read-in Level 2 document does or does not use
    SBML Layout.  Instead, callers have to query explicitly for the
    existence of layout information.  An example of such a query is the
    following code:

      # Assume 'doc' below is an SBMLDocument object.
      m = doc.getModel()
      if m != None:
          layoutPlugin = m.getPlugin('layout')
          if layoutPlugin != None:
              numLayouts = layoutPlugin.getNumLayouts()
              # If numLayouts is greater than zero, then the model uses Layout.

    The special, always-available Level 2 Layout behavior was motivated
    by a desire to support legacy applications.  In SBML Level 3, the
    Layout package uses the normal SBML Level 3 scheme of requiring
    declarations on the SBML document element.  This means that upon
    reading a model, libSBML knows right away whether it contains layout
    information. In SBML Level 2, there is no top-level declaration
    because layout is stored as annotations in the body of the model.
    Detecting the presence of layout information when reading a Level 2
    model requires parsing the annotations.  For efficiency reasons,
    libSBML normally does not parse annotations automatically when reading
    a model.  However, applications that predated the introduction of
    Level 3 Layout and the updated version of libSBML never had to do
    anything special to enable parsing layout; the facilities were always
    available for every Level 2 model as long as libSBML was compiled with
    Layout support.  To avoid burdening developers of legacy applications
    with the need to modify their software, libSBML provides backward
    compatibility by always preloading the Layout package extension when
    reading Level 2 models.  The same applies to the creation of Level 2
    models: with the plugin-oriented libSBML, applications normally would
    have to take deliberate steps to activate package code, instantiate
    objects, manage namespaces, and so on.  LibSBML again loads the Layout
    package plugin automatically when creating a Level 2 model, thereby
    making the APIs available to legacy applications without further work
    on their part.

    """

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLExtension, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SBMLExtension, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_SBMLExtension
    __del__ = lambda self: None

    def getNumOfSBasePlugins(self):
        """
        getNumOfSBasePlugins(SBMLExtension self) -> int


        Returns the number of SBasePluginCreatorBase objects stored in this
        object.

        Returns the total number of SBasePluginCreatorBase objects stored in
        this SBMLExtension-derived object.

        """
        return _libsbml.SBMLExtension_getNumOfSBasePlugins(self)


    def getNumOfSupportedPackageURI(self):
        """
        getNumOfSupportedPackageURI(SBMLExtension self) -> unsigned int


        Returns the number of supported package namespace URIs.

        Returns the number of supported package XML namespace URIs of this
        package extension.

        """
        return _libsbml.SBMLExtension_getNumOfSupportedPackageURI(self)


    def isSupported(self, uri):
        """
        isSupported(SBMLExtension self, string uri) -> bool


        Returns 'True' if the given XML namespace URI is supported by this
        package extension.

        Returns 'True' if the given XML namespace URI (equivalent to a package
        version) is supported by this package extension, 'False' otherwise.

        """
        return _libsbml.SBMLExtension_isSupported(self, uri)


    def getSupportedPackageURI(self, n):
        """
        getSupportedPackageURI(SBMLExtension self, unsigned int n) -> string


        Returns the nth XML namespace URI.

        Parameter 'n' is the index number of the namespace URI being sought.
        Returns a string representing the XML namespace URI understood to be
        supported by this package.  An empty string will be returned if there
        is no nth URI.

        """
        return _libsbml.SBMLExtension_getSupportedPackageURI(self, n)


    def clone(self):
        """
        clone(SBMLExtension self) -> SBMLExtension


        Creates and returns a deep copy of this SBMLExtension object.

        Returns a (deep) copy of this SBMLExtension object.

        Note: This is a method that package extension implementations must
        override. See the libSBML documentation on extending libSBML to
        support SBML packages for more information on this topic.

        """
        return _libsbml.SBMLExtension_clone(self)


    def getName(self):
        """
        getName(SBMLExtension self) -> string


        Returns the nickname of this package.

        This returns the short-form name of an SBML Level 3 package
        implemented by a given SBMLExtension-derived class.  Examples of such
        names are 'layout', 'fbc', etc.

        Returns a string, the nickname of SBML package.

        Note: This is a method that package extension implementations must
        override. See the libSBML documentation on extending libSBML to
        support SBML packages for more information on this topic.

        """
        return _libsbml.SBMLExtension_getName(self)


    def getURI(self, sbmlLevel, sbmlVersion, pkgVersion):
        """
        getURI(SBMLExtension self, unsigned int sbmlLevel, unsigned int sbmlVersion, unsigned int pkgVersion) -> string


        Returns the XML namespace URI for a given Level and Version.

        Parameter 'sbmlLevel' is the SBML Level. Parameter 'sbmlVersion' is
        the SBML Version. Parameter 'pkgVersion' is the version of the
        package.

        Returns a string, the XML namespace URI for the package for the given
        SBML Level, SBML Version, and package version.

        Note: This is a method that package extension implementations must
        override. See the libSBML documentation on extending libSBML to
        support SBML packages for more information on this topic.

        """
        return _libsbml.SBMLExtension_getURI(self, sbmlLevel, sbmlVersion, pkgVersion)


    def getLevel(self, uri):
        """
        getLevel(SBMLExtension self, string uri) -> unsigned int


        Returns the SBML Level associated with the given XML namespace URI.

        Parameter 'uri' is the string of URI that represents a version of the
        package.

        Returns the SBML Level associated with the given URI of this package.

        Note: This is a method that package extension implementations must
        override. See the libSBML documentation on extending libSBML to
        support SBML packages for more information on this topic.

        """
        return _libsbml.SBMLExtension_getLevel(self, uri)


    def getVersion(self, uri):
        """
        getVersion(SBMLExtension self, string uri) -> unsigned int


        Returns the SBML Version associated with the given XML namespace URI.

        Parameter 'uri' is the string of URI that represents a version of the
        package.

        Returns the SBML Version associated with the given URI of this
        package.

        Note: This is a method that package extension implementations must
        override. See the libSBML documentation on extending libSBML to
        support SBML packages for more information on this topic.

        """
        return _libsbml.SBMLExtension_getVersion(self, uri)


    def getPackageVersion(self, uri):
        """
        getPackageVersion(SBMLExtension self, string uri) -> unsigned int


        Returns the package version associated with the given XML namespace
        URI.

        Parameter 'uri' is the string of URI that represents a version of this
        package.

        Returns the package version associated with the given URI of this
        package.

        Note: This is a method that package extension implementations must
        override. See the libSBML documentation on extending libSBML to
        support SBML packages for more information on this topic.

        """
        return _libsbml.SBMLExtension_getPackageVersion(self, uri)


    def getStringFromTypeCode(self, typeCode):
        """
        getStringFromTypeCode(SBMLExtension self, int typeCode) -> char const *


        Returns a string representation of a type code.

        This method takes a numerical type code 'typeCode' for a component
        object implemented by this package extension, and returns a string
        representing that type code.

        Parameter 'typeCode' is the type code to turn into a string.

        Returns the string representation of 'typeCode'.

        Note: This is a method that package extension implementations must
        override. See the libSBML documentation on extending libSBML to
        support SBML packages for more information on this topic.

        """
        return _libsbml.SBMLExtension_getStringFromTypeCode(self, typeCode)


    def getSBMLExtensionNamespaces(self, uri):
        """
        getSBMLExtensionNamespaces(SBMLExtension self, string uri) -> SBMLNamespaces


        Returns a specialized SBMLNamespaces object corresponding to a given
        namespace URI.

        LibSBML package extensions each define a subclass of SBMLNamespaces.

        The present method returns the appropriate object corresponding to the
        given XML namespace URI in argument 'uri'.

        Parameter 'uri' is the namespace URI that represents one of versions
        of the package implemented in this extension.

        Returns an SBMLNamespaces   object, or 'None' if the given 'uri' is
        not defined in the corresponding package.

        Note: This is a method that package extension implementations must
        override. See the libSBML documentation on extending libSBML to
        support SBML packages for more information on this topic.

        """
        return _libsbml.SBMLExtension_getSBMLExtensionNamespaces(self, uri)


    def setEnabled(self, isEnabled):
        """
        setEnabled(SBMLExtension self, bool isEnabled) -> bool


        Enable or disable this package.

        Parameter 'isEnabled' is flag indicating whether to enable (if 'True)'
        or disable ('False)' this package extension.

        Returns 'True' if this call succeeded; 'False' otherwise.

        """
        return _libsbml.SBMLExtension_setEnabled(self, isEnabled)


    def isEnabled(self):
        """
        isEnabled(SBMLExtension self) -> bool


        Returns 'True' if this package is enabled.

        Returns 'True' if this package is enabled, 'False' otherwise.

        """
        return _libsbml.SBMLExtension_isEnabled(self)


    def removeL2Namespaces(self, xmlns):
        """
        removeL2Namespaces(SBMLExtension self, XMLNamespaces xmlns)


        Internal implementation method.

        """
        return _libsbml.SBMLExtension_removeL2Namespaces(self, xmlns)


    def addL2Namespaces(self, xmlns):
        """
        addL2Namespaces(SBMLExtension self, XMLNamespaces xmlns)


        Internal implementation method.

        """
        return _libsbml.SBMLExtension_addL2Namespaces(self, xmlns)


    def enableL2NamespaceForDocument(self, doc):
        """
        enableL2NamespaceForDocument(SBMLExtension self, SBMLDocument doc)


        Internal implementation method.

        """
        return _libsbml.SBMLExtension_enableL2NamespaceForDocument(self, doc)


    def isInUse(self, doc):
        """
        isInUse(SBMLExtension self, SBMLDocument doc) -> bool


        Indicates whether this extension is being used by the given
        SBMLDocument.

        The default implementation returns 'True.'  This means that when a
        document had this extension enabled, it will not be possible to
        convert it to SBML Level 2 as we cannot make sure that the extension
        can be converted.

        Parameter 'doc' is the SBML document to test.

        Returns a boolean indicating whether the extension is actually being
        used by the document.

        """
        return _libsbml.SBMLExtension_isInUse(self, doc)


    def hasMutiplePackageVersions(self):
        """
        hasMutiplePackageVersions(SBMLExtension self) -> bool


        Internal implementation method.

        """
        return _libsbml.SBMLExtension_hasMutiplePackageVersions(self)


    def getErrorTableIndex(self, errorId):
        """
        getErrorTableIndex(SBMLExtension self, unsigned int errorId) -> unsigned int


        Internal implementation method.

        """
        return _libsbml.SBMLExtension_getErrorTableIndex(self, errorId)


    def getErrorIdOffset(self):
        """
        getErrorIdOffset(SBMLExtension self) -> unsigned int


        Internal implementation method.

        """
        return _libsbml.SBMLExtension_getErrorIdOffset(self)


    def getSeverity(self, index, pkgVersion):
        """
        getSeverity(SBMLExtension self, unsigned int index, unsigned int pkgVersion) -> unsigned int


        Internal implementation method.

        """
        return _libsbml.SBMLExtension_getSeverity(self, index, pkgVersion)


    def getCategory(self, index):
        """
        getCategory(SBMLExtension self, unsigned int index) -> unsigned int


        Internal implementation method.

        """
        return _libsbml.SBMLExtension_getCategory(self, index)


    def getMessage(self, index, pkgVersion, details):
        """
        getMessage(SBMLExtension self, unsigned int index, unsigned int pkgVersion, string details) -> string


        Internal implementation method.

        """
        return _libsbml.SBMLExtension_getMessage(self, index, pkgVersion, details)


    def getShortMessage(self, index):
        """
        getShortMessage(SBMLExtension self, unsigned int index) -> string


        Internal implementation method.

        """
        return _libsbml.SBMLExtension_getShortMessage(self, index)


    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

SBMLExtension_swigregister = _libsbml.SBMLExtension_swigregister
SBMLExtension_swigregister(SBMLExtension)

class SBMLExtensionException(_object):
    """

    Exception used by package extensions

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    Certain situations can result in an exception being thrown by
    libSBML package extensions.  A prominent example involves the
    constructor for SBMLNamespaces (and its subclasses), which will throw
    SBMLExtensionException if the arguments it is given refer to an
    unknown SBML Level 3 package.  The situation can arise for legitimate
    SBML files if the necessary package extension has not been registered
    with a given copy of libSBML.

    See also SBMLNamespaces.

    """

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLExtensionException, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SBMLExtensionException, name)
    __repr__ = _swig_repr

    def __init__(self, errmsg):
        """
        __init__(SBMLExtensionException self, string errmsg) -> SBMLExtensionException


        Creates a new SBMLExtensionException object with a given message.

        Parameter 'errmsg' is a string, the text of the error message to store
        with this exception.

        """
        this = _libsbml.new_SBMLExtensionException(errmsg)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_SBMLExtensionException
    __del__ = lambda self: None
SBMLExtensionException_swigregister = _libsbml.SBMLExtensionException_swigregister
SBMLExtensionException_swigregister(SBMLExtensionException)

class SBMLExtensionRegistry(_object):
    """

    Registry where package extensions are registered.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    This class provides a central registry of all extensions known to
    libSBML. Each package extension must be registered with the registry.
    The registry class is accessed by various classes to retrieve
    information about known package extensions and to create additional
    attributes and/or elements by factory objects of the package
    extensions.

    The package extension registry is implemented as a singleton instance
    of SBMLExtensionRegistry.  The class provides only utility
    functionality; implementations of SBML packages do not need to
    implement any subclasses or methods of this class.
    SBMLExtensionRegistry is useful for its facilities to query the known
    packages, and to enable or disable packages selectively.

    """

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLExtensionRegistry, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SBMLExtensionRegistry, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def getInstance():
        """
        getInstance() -> SBMLExtensionRegistry


        Returns a singleton instance of the registry.

        Callers need to obtain a copy of the package extension registry before
        they can invoke its methods.  The registry is implemented as a
        singleton, and this is the method callers can use to get a copy of it.

        Returns the instance of the SBMLExtensionRegistry object.

        """
        return _libsbml.SBMLExtensionRegistry_getInstance()

    getInstance = staticmethod(getInstance)

    def addExtension(self, ext):
        """
        addExtension(SBMLExtensionRegistry self, SBMLExtension ext) -> int


        Add the given SBMLExtension object to this SBMLExtensionRegistry.

        Parameter 'ext' is the SBMLExtension object to be added.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_PKG_CONFLICT

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.SBMLExtensionRegistry_addExtension(self, ext)


    def getExtension(self, package):
        """
        getExtension(SBMLExtensionRegistry self, string package) -> SBMLExtension


        Returns an SBMLExtension object with the given package URI or package
        name.

        Parameter 'package' is a string representing the URI or name of the
        SBML package whose package extension is being sought.

        Returns a clone of the SBMLExtension object with the given package URI
        or name.

        Note: The caller is responsible for freeing the object returned.
        Since the object is a clone, freeing it will not result in the
        deletion of the original package extension object.

        """
        return _libsbml.SBMLExtensionRegistry_getExtension(self, package)


    def removeL2Namespaces(self, xmlns):
        """
        removeL2Namespaces(SBMLExtensionRegistry self, XMLNamespaces xmlns)


        Removes SBML Level 2 namespaces from the namespace list.

        Parameter 'xmlns' is an XMLNamespaces object listing one or more
        namespaces to be removed.

        """
        return _libsbml.SBMLExtensionRegistry_removeL2Namespaces(self, xmlns)


    def addL2Namespaces(self, xmlns):
        """
        addL2Namespaces(SBMLExtensionRegistry self, XMLNamespaces xmlns)


        Adds SBML Level 2 namespaces to the namespace list.

        Parameter 'xmlns' is an XMLNamespaces object providing one or more
        namespaces to be added.

        """
        return _libsbml.SBMLExtensionRegistry_addL2Namespaces(self, xmlns)


    def enableL2NamespaceForDocument(self, doc):
        """
        enableL2NamespaceForDocument(SBMLExtensionRegistry self, SBMLDocument doc)


        Enables package extensions that support serialization to SBML
        annotations.

        SBML Level 2 does not have a package mechanism in the way that SBML
        Level 3 does.  However, SBML annotations can be used to store SBML
        constructs.  In fact, a widely-used approach to developing SBML Level
        3 packages involves first using them as annotations.

        Parameter 'doc' is the SBMLDocument object for which this should be
        enabled.

        """
        return _libsbml.SBMLExtensionRegistry_enableL2NamespaceForDocument(self, doc)


    def disableUnusedPackages(self, doc):
        """
        disableUnusedPackages(SBMLExtensionRegistry self, SBMLDocument doc)


        Disables unused packages.

        This method walks through all extensions in the list of plugins of the
        given SBML document 'doc', and disables all that are not being used.

        Parameter 'doc' is the SBMLDocument object whose unused package
        extensions should be disabled.

        """
        return _libsbml.SBMLExtensionRegistry_disableUnusedPackages(self, doc)


    def disablePackage(package):
        """
        disablePackage(string package)


        Disables the package with the given URI or name.

        Parameter 'package' is a string representing the URI or name of the
        SBML package whose package extension is to be disabled.

        """
        return _libsbml.SBMLExtensionRegistry_disablePackage(package)

    disablePackage = staticmethod(disablePackage)

    def isPackageEnabled(package):
        """
        isPackageEnabled(string package) -> bool


        Returns 'True' if the named package is enabled.

        Parameter 'package' is the name or URI of a package to test.

        Returns 'True' if the package is enabled, 'False' otherwise.

        """
        return _libsbml.SBMLExtensionRegistry_isPackageEnabled(package)

    isPackageEnabled = staticmethod(isPackageEnabled)

    def enablePackage(package):
        """
        enablePackage(string package)


        Enables the package with the given URI / name.

        Parameter 'package' is the name or URI of a package to enable.

        """
        return _libsbml.SBMLExtensionRegistry_enablePackage(package)

    enablePackage = staticmethod(enablePackage)

    def getNumExtension(self, extPoint):
        """
        getNumExtension(SBMLExtensionRegistry self, SBaseExtensionPoint extPoint) -> unsigned int


        Returns the number of extensions that have a given extension point.

        Parameter 'extPoint' is the SBaseExtensionPoint object.

        Returns the number of SBMLExtension-derived objects with the given
        extension point.

        """
        return _libsbml.SBMLExtensionRegistry_getNumExtension(self, extPoint)


    def setEnabled(self, uri, isEnabled):
        """
        setEnabled(SBMLExtensionRegistry self, string uri, bool isEnabled) -> bool


        Enables or disable the package with the given URI.

        Parameter 'uri' is the URI of the target package. Parameter
        'isEnabled' is 'True' to enable the package, 'False' to disable.

        Returns 'False' if 'isEnabled' is 'False' or the given package is not
        registered, otherwise this method returns 'True.'

        """
        return _libsbml.SBMLExtensionRegistry_setEnabled(self, uri, isEnabled)


    def isEnabled(self, uri):
        """
        isEnabled(SBMLExtensionRegistry self, string uri) -> bool


        Returns 'True' if the given extension is enabled.

        Parameter 'uri' is the URI of the target package.

        Returns 'False' if the given package is disabled or not registered,
        'True' otherwise.

        """
        return _libsbml.SBMLExtensionRegistry_isEnabled(self, uri)


    def isRegistered(self, uri):
        """
        isRegistered(SBMLExtensionRegistry self, string uri) -> bool


        Returns 'True' if a package extension is registered for the
        corresponding package URI.

        Parameter 'uri' is the URI of the target package.

        Returns 'True' if the package with the given URI is registered,
        otherwise returns 'False.'

        """
        return _libsbml.SBMLExtensionRegistry_isRegistered(self, uri)


    def getAllRegisteredPackageNames():
        """
        getAllRegisteredPackageNames() -> std::vector< std::string >


        Returns a list of registered packages.

        This method returns a vector of strings containing the nicknames of
        the SBML packages for which package extensions are registered with
        this copy of libSBML.  The vector will contain string objects.

        Returns a vector of strings of the registered package names.

        """
        return _libsbml.SBMLExtensionRegistry_getAllRegisteredPackageNames()

    getAllRegisteredPackageNames = staticmethod(getAllRegisteredPackageNames)

    def getNumRegisteredPackages():
        """
        getNumRegisteredPackages() -> unsigned int


        Returns the number of registered packages.

        Returns a count of the registered package extensions.

        """
        return _libsbml.SBMLExtensionRegistry_getNumRegisteredPackages()

    getNumRegisteredPackages = staticmethod(getNumRegisteredPackages)

    def getRegisteredPackageName(index):
        """
        getRegisteredPackageName(unsigned int index) -> string


        Returns the nth registered package.

        Parameter 'index' is zero-based index of the package name to return.

        Returns the package name with the given index, or 'None' if none such
        exists.

        See also getNumRegisteredPackages().

        """
        return _libsbml.SBMLExtensionRegistry_getRegisteredPackageName(index)

    getRegisteredPackageName = staticmethod(getRegisteredPackageName)

    def getASTPlugins(self):
        """
        getASTPlugins(SBMLExtensionRegistry self) -> std::vector< ASTBasePlugin * >




        """
        return _libsbml.SBMLExtensionRegistry_getASTPlugins(self)


    def getNumASTPlugins(self):
        """
        getNumASTPlugins(SBMLExtensionRegistry self) -> unsigned int




        """
        return _libsbml.SBMLExtensionRegistry_getNumASTPlugins(self)


    def getASTPlugin(self, i):
        """
        getASTPlugin(SBMLExtensionRegistry self, unsigned int i) -> ASTBasePlugin




        """
        return _libsbml.SBMLExtensionRegistry_getASTPlugin(self, i)

SBMLExtensionRegistry_swigregister = _libsbml.SBMLExtensionRegistry_swigregister
SBMLExtensionRegistry_swigregister(SBMLExtensionRegistry)

def SBMLExtensionRegistry_getInstance():
    """
    SBMLExtensionRegistry_getInstance() -> SBMLExtensionRegistry


    Returns a singleton instance of the registry.

    Callers need to obtain a copy of the package extension registry before
    they can invoke its methods.  The registry is implemented as a
    singleton, and this is the method callers can use to get a copy of it.

    Returns the instance of the SBMLExtensionRegistry object.

    """
    return _libsbml.SBMLExtensionRegistry_getInstance()

def SBMLExtensionRegistry_disablePackage(package):
    """
    SBMLExtensionRegistry_disablePackage(string package)


    Disables the package with the given URI or name.

    Parameter 'package' is a string representing the URI or name of the
    SBML package whose package extension is to be disabled.

    """
    return _libsbml.SBMLExtensionRegistry_disablePackage(package)

def SBMLExtensionRegistry_isPackageEnabled(package):
    """
    SBMLExtensionRegistry_isPackageEnabled(string package) -> bool


    Returns 'True' if the named package is enabled.

    Parameter 'package' is the name or URI of a package to test.

    Returns 'True' if the package is enabled, 'False' otherwise.

    """
    return _libsbml.SBMLExtensionRegistry_isPackageEnabled(package)

def SBMLExtensionRegistry_enablePackage(package):
    """
    SBMLExtensionRegistry_enablePackage(string package)


    Enables the package with the given URI / name.

    Parameter 'package' is the name or URI of a package to enable.

    """
    return _libsbml.SBMLExtensionRegistry_enablePackage(package)

def SBMLExtensionRegistry_getAllRegisteredPackageNames():
    """
    SBMLExtensionRegistry_getAllRegisteredPackageNames() -> std::vector< std::string >


    Returns a list of registered packages.

    This method returns a vector of strings containing the nicknames of
    the SBML packages for which package extensions are registered with
    this copy of libSBML.  The vector will contain string objects.

    Returns a vector of strings of the registered package names.

    """
    return _libsbml.SBMLExtensionRegistry_getAllRegisteredPackageNames()

def SBMLExtensionRegistry_getNumRegisteredPackages():
    """
    SBMLExtensionRegistry_getNumRegisteredPackages() -> unsigned int


    Returns the number of registered packages.

    Returns a count of the registered package extensions.

    """
    return _libsbml.SBMLExtensionRegistry_getNumRegisteredPackages()

def SBMLExtensionRegistry_getRegisteredPackageName(index):
    """
    SBMLExtensionRegistry_getRegisteredPackageName(unsigned int index) -> string


    Returns the nth registered package.

    Parameter 'index' is zero-based index of the package name to return.

    Returns the package name with the given index, or 'None' if none such
    exists.

    See also getNumRegisteredPackages().

    """
    return _libsbml.SBMLExtensionRegistry_getRegisteredPackageName(index)

class Callback(_object):
    """Proxy of C++ Callback class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Callback, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Callback, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_Callback
    __del__ = lambda self: None

    def process(self, doc):
        """
        process(Callback self, SBMLDocument doc) -> int


        The processing function to be implemented by the callback

        In order to stop processing return a value other than
        LIBSBML_OPERATION_SUCCESS.

        Returns LIBSBML_OPERATION_SUCCESS to continue the operations any other
        value to stop

        """
        return _libsbml.Callback_process(self, doc)


    def __init__(self):
        """__init__(Callback self) -> Callback"""
        if self.__class__ == Callback:
            _self = None
        else:
            _self = self
        this = _libsbml.new_Callback(_self, )
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    def __disown__(self):
        self.this.disown()
        _libsbml.disown_Callback(self)
        return weakref_proxy(self)
Callback_swigregister = _libsbml.Callback_swigregister
Callback_swigregister(Callback)

class CallbackRegistry(_object):
    """Proxy of C++ CallbackRegistry class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CallbackRegistry, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CallbackRegistry, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def invokeCallbacks(doc):
        """
        invokeCallbacks(SBMLDocument doc) -> int


        Invokes all registered callbacks on the given document. If the
        callbacks indicate that processing should be stopped they return a
        value other than operation success.

        Returns LIBSBML_OPERATION_SUCCESS to indicate that processing should
        be continued,  any other value to stop processing

        """
        return _libsbml.CallbackRegistry_invokeCallbacks(doc)

    invokeCallbacks = staticmethod(invokeCallbacks)

    def clearCallbacks():
        """
        clearCallbacks()


        Clears all registered processing callbacks

        """
        return _libsbml.CallbackRegistry_clearCallbacks()

    clearCallbacks = staticmethod(clearCallbacks)

    def addCallback(cb):
        """
        addCallback(Callback cb)


        Registers a new processing callback that will be called with a newly
        instantiated ModelDefinition object. This allows for all post
        processing on it that needs to happen before integrating it with the
        target document.

        Parameter 'cb' is the callback.

        """
        return _libsbml.CallbackRegistry_addCallback(cb)

    addCallback = staticmethod(addCallback)

    def getNumCallbacks():
        """
        getNumCallbacks() -> int


        Returns the number of registered callbacks.

        """
        return _libsbml.CallbackRegistry_getNumCallbacks()

    getNumCallbacks = staticmethod(getNumCallbacks)

    def removeCallback(*args):
        """
        removeCallback(int index)
        removeCallback(Callback cb)


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeCallback(Callback *cb)

        Removes the specified callback from the list of registered callbacks

        Parameter 'cb' is the callback to be removed.

        ______________________________________________________________________
        Method variant with the following signature:

            removeCallback(int index)

        Removes the callback with given index.

        Parameter 'index' is the index of the callback to be removed from the
        list.

        """
        return _libsbml.CallbackRegistry_removeCallback(*args)

    removeCallback = staticmethod(removeCallback)
    __swig_destroy__ = _libsbml.delete_CallbackRegistry
    __del__ = lambda self: None
CallbackRegistry_swigregister = _libsbml.CallbackRegistry_swigregister
CallbackRegistry_swigregister(CallbackRegistry)

def CallbackRegistry_invokeCallbacks(doc):
    """
    CallbackRegistry_invokeCallbacks(SBMLDocument doc) -> int


    Invokes all registered callbacks on the given document. If the
    callbacks indicate that processing should be stopped they return a
    value other than operation success.

    Returns LIBSBML_OPERATION_SUCCESS to indicate that processing should
    be continued,  any other value to stop processing

    """
    return _libsbml.CallbackRegistry_invokeCallbacks(doc)

def CallbackRegistry_clearCallbacks():
    """
    CallbackRegistry_clearCallbacks()


    Clears all registered processing callbacks

    """
    return _libsbml.CallbackRegistry_clearCallbacks()

def CallbackRegistry_addCallback(cb):
    """
    CallbackRegistry_addCallback(Callback cb)


    Registers a new processing callback that will be called with a newly
    instantiated ModelDefinition object. This allows for all post
    processing on it that needs to happen before integrating it with the
    target document.

    Parameter 'cb' is the callback.

    """
    return _libsbml.CallbackRegistry_addCallback(cb)

def CallbackRegistry_getNumCallbacks():
    """
    CallbackRegistry_getNumCallbacks() -> int


    Returns the number of registered callbacks.

    """
    return _libsbml.CallbackRegistry_getNumCallbacks()

def CallbackRegistry_removeCallback(*args):
    """
    removeCallback(int index)
    CallbackRegistry_removeCallback(Callback cb)


    This method has multiple variants; they differ in the arguments  they
    accept.  Each variant is described separately below.

    ______________________________________________________________________
    Method variant with the following signature:

        removeCallback(Callback *cb)

    Removes the specified callback from the list of registered callbacks

    Parameter 'cb' is the callback to be removed.

    ______________________________________________________________________
    Method variant with the following signature:

        removeCallback(int index)

    Removes the callback with given index.

    Parameter 'index' is the index of the callback to be removed from the
    list.

    """
    return _libsbml.CallbackRegistry_removeCallback(*args)

EM_L3V2 = _libsbml.EM_L3V2
EM_DISTRIB = _libsbml.EM_DISTRIB
EM_ARRAYS = _libsbml.EM_ARRAYS
EM_UNKNOWN = _libsbml.EM_UNKNOWN
ALLOWED_CHILDREN_ANY = _libsbml.ALLOWED_CHILDREN_ANY
ALLOWED_CHILDREN_ATLEAST = _libsbml.ALLOWED_CHILDREN_ATLEAST
ALLOWED_CHILDREN_EXACTLY = _libsbml.ALLOWED_CHILDREN_EXACTLY
ALLOWED_CHILDREN_UNKNOWN = _libsbml.ALLOWED_CHILDREN_UNKNOWN
AST_PLUS = _libsbml.AST_PLUS
AST_MINUS = _libsbml.AST_MINUS
AST_TIMES = _libsbml.AST_TIMES
AST_DIVIDE = _libsbml.AST_DIVIDE
AST_POWER = _libsbml.AST_POWER
AST_INTEGER = _libsbml.AST_INTEGER
AST_REAL = _libsbml.AST_REAL
AST_REAL_E = _libsbml.AST_REAL_E
AST_RATIONAL = _libsbml.AST_RATIONAL
AST_NAME = _libsbml.AST_NAME
AST_NAME_AVOGADRO = _libsbml.AST_NAME_AVOGADRO
AST_NAME_TIME = _libsbml.AST_NAME_TIME
AST_CONSTANT_E = _libsbml.AST_CONSTANT_E
AST_CONSTANT_FALSE = _libsbml.AST_CONSTANT_FALSE
AST_CONSTANT_PI = _libsbml.AST_CONSTANT_PI
AST_CONSTANT_TRUE = _libsbml.AST_CONSTANT_TRUE
AST_LAMBDA = _libsbml.AST_LAMBDA
AST_FUNCTION = _libsbml.AST_FUNCTION
AST_FUNCTION_ABS = _libsbml.AST_FUNCTION_ABS
AST_FUNCTION_ARCCOS = _libsbml.AST_FUNCTION_ARCCOS
AST_FUNCTION_ARCCOSH = _libsbml.AST_FUNCTION_ARCCOSH
AST_FUNCTION_ARCCOT = _libsbml.AST_FUNCTION_ARCCOT
AST_FUNCTION_ARCCOTH = _libsbml.AST_FUNCTION_ARCCOTH
AST_FUNCTION_ARCCSC = _libsbml.AST_FUNCTION_ARCCSC
AST_FUNCTION_ARCCSCH = _libsbml.AST_FUNCTION_ARCCSCH
AST_FUNCTION_ARCSEC = _libsbml.AST_FUNCTION_ARCSEC
AST_FUNCTION_ARCSECH = _libsbml.AST_FUNCTION_ARCSECH
AST_FUNCTION_ARCSIN = _libsbml.AST_FUNCTION_ARCSIN
AST_FUNCTION_ARCSINH = _libsbml.AST_FUNCTION_ARCSINH
AST_FUNCTION_ARCTAN = _libsbml.AST_FUNCTION_ARCTAN
AST_FUNCTION_ARCTANH = _libsbml.AST_FUNCTION_ARCTANH
AST_FUNCTION_CEILING = _libsbml.AST_FUNCTION_CEILING
AST_FUNCTION_COS = _libsbml.AST_FUNCTION_COS
AST_FUNCTION_COSH = _libsbml.AST_FUNCTION_COSH
AST_FUNCTION_COT = _libsbml.AST_FUNCTION_COT
AST_FUNCTION_COTH = _libsbml.AST_FUNCTION_COTH
AST_FUNCTION_CSC = _libsbml.AST_FUNCTION_CSC
AST_FUNCTION_CSCH = _libsbml.AST_FUNCTION_CSCH
AST_FUNCTION_DELAY = _libsbml.AST_FUNCTION_DELAY
AST_FUNCTION_EXP = _libsbml.AST_FUNCTION_EXP
AST_FUNCTION_FACTORIAL = _libsbml.AST_FUNCTION_FACTORIAL
AST_FUNCTION_FLOOR = _libsbml.AST_FUNCTION_FLOOR
AST_FUNCTION_LN = _libsbml.AST_FUNCTION_LN
AST_FUNCTION_LOG = _libsbml.AST_FUNCTION_LOG
AST_FUNCTION_PIECEWISE = _libsbml.AST_FUNCTION_PIECEWISE
AST_FUNCTION_POWER = _libsbml.AST_FUNCTION_POWER
AST_FUNCTION_ROOT = _libsbml.AST_FUNCTION_ROOT
AST_FUNCTION_SEC = _libsbml.AST_FUNCTION_SEC
AST_FUNCTION_SECH = _libsbml.AST_FUNCTION_SECH
AST_FUNCTION_SIN = _libsbml.AST_FUNCTION_SIN
AST_FUNCTION_SINH = _libsbml.AST_FUNCTION_SINH
AST_FUNCTION_TAN = _libsbml.AST_FUNCTION_TAN
AST_FUNCTION_TANH = _libsbml.AST_FUNCTION_TANH
AST_LOGICAL_AND = _libsbml.AST_LOGICAL_AND
AST_LOGICAL_NOT = _libsbml.AST_LOGICAL_NOT
AST_LOGICAL_OR = _libsbml.AST_LOGICAL_OR
AST_LOGICAL_XOR = _libsbml.AST_LOGICAL_XOR
AST_RELATIONAL_EQ = _libsbml.AST_RELATIONAL_EQ
AST_RELATIONAL_GEQ = _libsbml.AST_RELATIONAL_GEQ
AST_RELATIONAL_GT = _libsbml.AST_RELATIONAL_GT
AST_RELATIONAL_LEQ = _libsbml.AST_RELATIONAL_LEQ
AST_RELATIONAL_LT = _libsbml.AST_RELATIONAL_LT
AST_RELATIONAL_NEQ = _libsbml.AST_RELATIONAL_NEQ
AST_END_OF_CORE = _libsbml.AST_END_OF_CORE
AST_FUNCTION_MAX = _libsbml.AST_FUNCTION_MAX
AST_FUNCTION_MIN = _libsbml.AST_FUNCTION_MIN
AST_FUNCTION_QUOTIENT = _libsbml.AST_FUNCTION_QUOTIENT
AST_FUNCTION_RATE_OF = _libsbml.AST_FUNCTION_RATE_OF
AST_FUNCTION_REM = _libsbml.AST_FUNCTION_REM
AST_LOGICAL_IMPLIES = _libsbml.AST_LOGICAL_IMPLIES
AST_CSYMBOL_FUNCTION = _libsbml.AST_CSYMBOL_FUNCTION
AST_DISTRIB_FUNCTION_NORMAL = _libsbml.AST_DISTRIB_FUNCTION_NORMAL
AST_DISTRIB_FUNCTION_UNIFORM = _libsbml.AST_DISTRIB_FUNCTION_UNIFORM
AST_DISTRIB_FUNCTION_BERNOULLI = _libsbml.AST_DISTRIB_FUNCTION_BERNOULLI
AST_DISTRIB_FUNCTION_BINOMIAL = _libsbml.AST_DISTRIB_FUNCTION_BINOMIAL
AST_DISTRIB_FUNCTION_CAUCHY = _libsbml.AST_DISTRIB_FUNCTION_CAUCHY
AST_DISTRIB_FUNCTION_CHISQUARE = _libsbml.AST_DISTRIB_FUNCTION_CHISQUARE
AST_DISTRIB_FUNCTION_EXPONENTIAL = _libsbml.AST_DISTRIB_FUNCTION_EXPONENTIAL
AST_DISTRIB_FUNCTION_GAMMA = _libsbml.AST_DISTRIB_FUNCTION_GAMMA
AST_DISTRIB_FUNCTION_LAPLACE = _libsbml.AST_DISTRIB_FUNCTION_LAPLACE
AST_DISTRIB_FUNCTION_LOGNORMAL = _libsbml.AST_DISTRIB_FUNCTION_LOGNORMAL
AST_DISTRIB_FUNCTION_POISSON = _libsbml.AST_DISTRIB_FUNCTION_POISSON
AST_DISTRIB_FUNCTION_RAYLEIGH = _libsbml.AST_DISTRIB_FUNCTION_RAYLEIGH
AST_LINEAR_ALGEBRA_VECTOR = _libsbml.AST_LINEAR_ALGEBRA_VECTOR
AST_LINEAR_ALGEBRA_SELECTOR = _libsbml.AST_LINEAR_ALGEBRA_SELECTOR
AST_LINEAR_ALGEBRA_MATRIX = _libsbml.AST_LINEAR_ALGEBRA_MATRIX
AST_LINEAR_ALGEBRA_MATRIXROW = _libsbml.AST_LINEAR_ALGEBRA_MATRIXROW
AST_LINEAR_ALGEBRA_DETERMINANT = _libsbml.AST_LINEAR_ALGEBRA_DETERMINANT
AST_LINEAR_ALGEBRA_TRANSPOSE = _libsbml.AST_LINEAR_ALGEBRA_TRANSPOSE
AST_LINEAR_ALGEBRA_VECTOR_PRODUCT = _libsbml.AST_LINEAR_ALGEBRA_VECTOR_PRODUCT
AST_LINEAR_ALGEBRA_SCALAR_PRODUCT = _libsbml.AST_LINEAR_ALGEBRA_SCALAR_PRODUCT
AST_LINEAR_ALGEBRA_OUTER_PRODUCT = _libsbml.AST_LINEAR_ALGEBRA_OUTER_PRODUCT
AST_LOGICAL_EXISTS = _libsbml.AST_LOGICAL_EXISTS
AST_LOGICAL_FORALL = _libsbml.AST_LOGICAL_FORALL
AST_STATISTICS_MEAN = _libsbml.AST_STATISTICS_MEAN
AST_STATISTICS_MEDIAN = _libsbml.AST_STATISTICS_MEDIAN
AST_STATISTICS_MODE = _libsbml.AST_STATISTICS_MODE
AST_STATISTICS_MOMENT = _libsbml.AST_STATISTICS_MOMENT
AST_SERIES_PRODUCT = _libsbml.AST_SERIES_PRODUCT
AST_STATISTICS_SDEV = _libsbml.AST_STATISTICS_SDEV
AST_SERIES_SUM = _libsbml.AST_SERIES_SUM
AST_STATISTICS_VARIANCE = _libsbml.AST_STATISTICS_VARIANCE
AST_UNKNOWN = _libsbml.AST_UNKNOWN
class ASTNode(_object):
    """

    Abstract Syntax Tree (AST) representation of a mathematical
    expression.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    Abstract Syntax Trees (ASTs) are a simple kind of data structure used
    in libSBML for storing mathematical expressions.  The ASTNode is the
    cornerstone of libSBML's AST representation.  An AST 'node' represents
    the most basic, indivisible part of a mathematical formula and come in
    many types.  For instance, there are node types to represent numbers
    (with subtypes to distinguish integer, real, and rational numbers),
    names (e.g., constants or variables), simple mathematical operators,
    logical or relational operators and functions. LibSBML ASTs provide a
    canonical, in-memory representation for all mathematical formulas
    regardless of their original format (which might be MathML or might be
    text strings).

    An AST node in libSBML is a recursive tree structure; each node has a
    type, a pointer to a value, and a list of children nodes.  Each
    ASTNode node may have none, one, two, or more children depending on
    its type. There are node types to represent numbers (with subtypes to
    distinguish integer, real, and rational numbers), names (e.g.,
    constants or variables), simple mathematical operators, logical or
    relational operators and functions.  The following diagram illustrates
    an example of how the mathematical expression '1 + 2' is represented
    as an AST with one plus node having two integer children nodes for the
    numbers 1 and 2.  The figure also shows the corresponding MathML
    representation:

      +-------+-----------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------+
      | Infix | AST                                                                                                 | MathML                                                                                                                                           |
      +-------+-----------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------+
      | 1 + 2 | <object type="image/svg+xml" data="simple-ast.svg" class="centered" width="140px"></object> | <math xmlns="http://www.w3.org/1998/Math/MathML"> <apply> <plus/> <cn type="integer"> 1 </cn> <cn type="integer"> 2 </cn> </apply> </math> |
      +-------+-----------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------+

    The following are other noteworthy points about the AST
    representation in libSBML:

    * A numerical value represented in MathML as a real number with an
    exponent is preserved as such in the AST node representation, even if
    the number could be stored in a 'float' data type.  This is done so
    that when an SBML model is read in and then written out again, the
    amount of change introduced by libSBML to the SBML during the round-
    trip activity is minimized.

    * Rational numbers are represented in an AST node using separate
    numerator and denominator values.  These can be retrieved using the
    methods ASTNode.getNumerator() and ASTNode.getDenominator().

    * The children of an ASTNode are other ASTNode objects.  The list
    of children is empty for nodes that are leaf elements, such as
    numbers. For nodes that are actually roots of expression subtrees, the
    list of children points to the parsed objects that make up the rest of
    the expression.

    For many applications, the details of ASTs are irrelevant because
    libSBML provides text-string based translation functions such as
    formulaToL3String() and parseL3Formula().  If you find the complexity
    of using the AST representation of expressions too high for your
    purposes, perhaps the string-based functions will be more suitable.

    The set of possible ASTNode types
    ......................................................................

    Every ASTNode has an associated type code to indicate whether, for
    example, it holds a number or stands for an arithmetic operator.

    The type is recorded as a value drawn from a set of static integer
    constants defined in the class 'libsbml'. Their names begin with the
    characters 'AST_.'

    The list of possible types is quite long, because it covers all the
    mathematical functions that are permitted in SBML. The values are
    shown in the following table:

       AST_CONSTANT_E                AST_FUNCTION_CSC         AST_LOGICAL_AND       
       AST_CONSTANT_FALSE            AST_FUNCTION_CSCH        AST_LOGICAL_IMPLIES^2 
       AST_CONSTANT_PI               AST_FUNCTION_DELAY       AST_LOGICAL_NOT       
       AST_CONSTANT_TRUE             AST_FUNCTION_EXP         AST_LOGICAL_OR        
       AST_DIVIDE                    AST_FUNCTION_FACTORIAL   AST_LOGICAL_XOR       
       AST_FUNCTION                  AST_FUNCTION_FLOOR       AST_MINUS             
       AST_FUNCTION_ABS              AST_FUNCTION_LN          AST_NAME              
       AST_FUNCTION_ARCCOS           AST_FUNCTION_LOG         AST_NAME_AVOGADRO^1   
       AST_FUNCTION_ARCCOSH          AST_FUNCTION_MAX^2       AST_NAME_TIME         
       AST_FUNCTION_ARCCOT           AST_FUNCTION_MIN^2                             
       AST_FUNCTION_ARCCOTH          AST_FUNCTION_PIECEWISE   AST_PLUS              
       AST_FUNCTION_ARCCSC           AST_FUNCTION_POWER       AST_POWER             
       AST_FUNCTION_ARCCSCH          AST_FUNCTION_QUOTIENT^2  AST_RATIONAL          
       AST_FUNCTION_ARCSEC           AST_FUNCTION_RATE_OF^2   AST_REAL              
       AST_FUNCTION_ARCSECH          AST_FUNCTION_REM^2       AST_REAL_E            
       AST_FUNCTION_ARCSIN           AST_FUNCTION_ROOT        AST_RELATIONAL_EQ     
       AST_FUNCTION_ARCSINH          AST_FUNCTION_SEC         AST_RELATIONAL_GEQ    
       AST_FUNCTION_ARCTAN           AST_FUNCTION_SECH        AST_RELATIONAL_GT     
       AST_FUNCTION_ARCTANH          AST_FUNCTION_SIN         AST_RELATIONAL_LEQ    
       AST_FUNCTION_CEILING          AST_FUNCTION_SINH        AST_RELATIONAL_LT     
       AST_FUNCTION_COS              AST_FUNCTION_TAN         AST_RELATIONAL_NEQ    
       AST_FUNCTION_COSH             AST_FUNCTION_TANH        AST_TIMES             
       AST_FUNCTION_COT              AST_INTEGER              AST_UNKNOWN           
       AST_FUNCTION_COTH             AST_LAMBDA                                     
       ^1 (Level 3 only)<br/>                                                       
       ^2 (Level 3 Version 2+ only)

    The types have the following meanings:

    * If the node is basic mathematical operator (e.g., ''+'),' then
    the node's type will be AST_PLUS, AST_MINUS, AST_TIMES, AST_DIVIDE, or
    AST_POWER, as appropriate.

    * If the node is a predefined function or operator from SBML Level
    1 (in the string-based formula syntax used in Level 1) or SBML Level 2
    and 3 (in the subset of MathML used in SBML Levels 2 and 3), then the
    node's type will be either AST_FUNCTION_X, AST_LOGICAL_X, or
    AST_RELATIONAL_X, as appropriate.  (Examples: AST_FUNCTION_LOG,
    AST_RELATIONAL_LEQ.)

    * If the node refers to a user-defined function, the node's type
    will be AST_FUNCTION (because it holds the name of the function).

    * If the node is a lambda expression, its type will be AST_LAMBDA.

    * If the node is a predefined constant (''ExponentialE',' ''Pi','
    ''True'' or ''False'),' then the node's type will be AST_CONSTANT_E,
    AST_CONSTANT_PI, AST_CONSTANT_TRUE, or AST_CONSTANT_FALSE.

    * (Levels 2 and 3 only) If the node is the special MathML csymbol
    'time,' the value of the node will be AST_NAME_TIME.  (Note, however,
    that the MathML csymbol 'delay' is translated into a node of type
    AST_FUNCTION_DELAY.  The difference is due to the fact that 'time' is
    a single variable, whereas 'delay' is actually a function taking
    arguments.)

    * (Level 3 only) If the node is the special MathML csymbol
    'avogadro,' the value of the node will be AST_NAME_AVOGADRO.

    * (Level 3 Version 2+ only) If the node is the special MathML
    csymbol 'rateOf,' the value of the node will be AST_FUNCTION_RATE_OF.

    * (Level 3 Version 2+ only) If the node is a MathML  operator that
    originates in a package, it is included in the ASTNodeType_t list, but
    may not be legally used in an SBML document that does not include that
    package.  This includes the node types from the 'Distributions'
    package (AST_DISTRIB_FUNCTION_NORMAL, AST_DISTRIB_FUNCTION_UNIFORM,
    etc.), and elements from MathML that were not included in core.

    * If the node contains a numerical value, its type will be
    AST_INTEGER, AST_REAL, AST_REAL_E, or AST_RATIONAL, as appropriate.

    Converting between ASTs and text strings
    ......................................................................

    The text-string form of mathematical formulas produced by
    libsbml.formulaToString() and read by libsbml.parseFormula() and
    libsbml.parseL3Formula() are in a simple C-inspired infix notation.  A
    formula in this text-string form can be handed to a program that
    understands SBML mathematical expressions, or used as part of a
    translation system.  The libSBML distribution comes with an example
    program in the ''examples'' subdirectory called 'translateMath' that
    implements an interactive command-line demonstration of translating
    infix formulas into MathML and vice-versa.

    The formula strings may contain operators, function calls, symbols,
    and white space characters.  The allowable white space characters are
    tab and space.  The following are illustrative examples of formulas
    expressed in the syntax:

      0.10 * k4^2

      (vm * s1)/(km + s1)

    The following table shows the precedence rules in this syntax.  In the
    Class column, operand implies the construct is an operand, prefix
    implies the operation is applied to the following arguments, unary
    implies there is one argument, and binary implies there are two
    arguments.  The values in the Precedence column show how the order of
    different types of operation are determined.  For example, the
    expression a * b + c is evaluated as (a * b) + c because the *
    operator has higher precedence.  The Associates column shows how the
    order of similar precedence operations is determined; for example, a -
    b + c is evaluated as (a - b) + c because the + and - operators are
    left-associative.  The precedence and associativity rules are taken
    from the C programming language, except for the symbol ^, which is
    used in C for a different purpose.  (Exponentiation can be invoked
    using either ^ or the function 'power.)'

      +--------------+---------------------+---------+------------+------------+
      | Token        | Operation           | Class   | Precedence | Associates |
      +--------------+---------------------+---------+------------+------------+
      | name         | symbol reference    | operand | 6          | n/a        |
      | (expression) | expression grouping | operand | 6          | n/a        |
      | f(...)       | function call       | prefix  | 6          | left       |
      | -            | negation            | unary   | 5          | right      |
      | ^            | power               | binary  | 4          | left       |
      | *            | multiplication      | binary  | 3          | left       |
      | /            | divison             | binary  | 3          | left       |
      | +            | addition            | binary  | 2          | left       |
      | -            | subtraction         | binary  | 2          | left       |
      | ,            | argument delimiter  | binary  | 1          | left       |
      +--------------+---------------------+---------+------------+------------+

    A program parsing a formula in an SBML model should assume that names
    appearing in the formula are the identifiers of Species, Parameter,
    Compartment, FunctionDefinition, Reaction (in SBML Levels 2 and 3), or
    SpeciesReference (in SBML Level 3 only) objects defined in a model.
    When a function call is involved, the syntax consists of a function
    identifier, followed by optional white space, followed by an opening
    parenthesis, followed by a sequence of zero or more arguments
    separated by commas (with each comma optionally preceded and/or
    followed by zero or more white space characters), followed by a
    closing parenthesis.  There is an almost one-to-one mapping between
    the list of predefined functions available, and those defined in
    MathML. All of the MathML functions are recognized; this set is larger
    than the functions defined in SBML Level 1.  In the subset of
    functions that overlap between MathML and SBML Level 1, there exist a
    few differences.  The following table summarizes the differences
    between the predefined functions in SBML Level 1 and the MathML
    equivalents in SBML Levels 2 and  3:

      +-------------------------------+-------------------------------------------+
      | Text string formula functions | MathML equivalents in SBML Levels 2 and 3 |
      +-------------------------------+-------------------------------------------+
      | acos                          | arccos                                    |
      | asin                          | arcsin                                    |
      | atan                          | arctan                                    |
      | ceil                          | ceiling                                   |
      | log                           | ln                                        |
      | log10(x)                      | log(x) or log(10, x)                      |
      | pow(x, y)                     | power(x, y)                               |
      | sqr(x)                        | power(x, 2)                               |
      | sqrt(x)                       | root(x) or root(2, x)                     |
      +-------------------------------+-------------------------------------------+

    @copydetails doc_warning_L1_math_string_syntax

    See also libsbml.parseL3Formula(), libsbml.parseFormula().

    """

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ASTNode, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ASTNode, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ASTNode self, ASTNodeType_t type=AST_UNKNOWN) -> ASTNode
        __init__(ASTNode self) -> ASTNode
        __init__(ASTNode self, ASTNode orig) -> ASTNode


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ASTNode(ASTNode orig)

        Copy constructor; creates a deep copy of the given ASTNode.

        Parameter 'orig' is the ASTNode to be copied.

        ______________________________________________________________________
        Method variant with the following signature:

            ASTNode(Token_t *token)

        Creates a new ASTNode from the given Token.  The resulting ASTNode
        will contain the same data as the Token.

        Parameter 'token' is the Token to add.

        ______________________________________________________________________
        Method variant with the following signature:

            ASTNode(ASTNodeType_t type = AST_UNKNOWN)

        Creates and returns a new ASTNode.

        Unless the argument 'type' is given, the returned node will by default
        have a type of AST_UNKNOWN.  If the type isn't supplied when caling
        this constructor, the caller should set the node type to something
        else as soon as possible using ASTNode.setType().

        Parameter 'type' is an optional type code indicating the type of node
        to create.

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        this = _libsbml.new_ASTNode(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_ASTNode
    __del__ = lambda self: None

    def freeName(self):
        """
        freeName(ASTNode self) -> int


        Frees the name of this ASTNode and sets it to 'None.'

        This operation is only applicable to ASTNode objects corresponding to
        operators, numbers, or AST_UNKNOWN.  This method has no effect on
        other types of nodes.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        """
        return _libsbml.ASTNode_freeName(self)


    def canonicalize(self):
        """
        canonicalize(ASTNode self) -> bool


        Converts this ASTNode to a canonical form and returns 'True' if
        successful, 'False' otherwise.

        The rules determining the canonical form conversion are as follows:

        * If the node type is AST_NAME and the node name matches
        ''ExponentialE',' ''Pi',' ''True'' or ''False'' the node type is
        converted to the corresponding  AST_CONSTANT_X type.

        * If the node type is an AST_FUNCTION and the node name matches an
        SBML (MathML) function name, logical operator name, or relational
        operator name, the node is converted to the corresponding
        AST_FUNCTION_X or AST_LOGICAL_X type.

        SBML Level 1 function names are searched first; thus, for example,
        canonicalizing 'log' will result in a node type of AST_FUNCTION_LN.
        (See the SBML Level 1 Version 2 Specification, Appendix C.)

        Sometimes, canonicalization of a node results in a structural
        conversion of the node as a result of adding a child.  For example, a
        node with the SBML Level 1 function name 'sqr' and a single child node
        (the argument) will be transformed to a node of type
        AST_FUNCTION_POWER with two children.  The first child will remain
        unchanged, but the second child will be an ASTNode of type AST_INTEGER
        and a value of 2.  The function names that result in structural
        changes are: 'log10,' 'sqr,' and 'sqrt.'

        """
        return _libsbml.ASTNode_canonicalize(self)


    def addChild(self, disownedChild, inRead=False):
        """
        addChild(ASTNode self, ASTNode disownedChild, bool inRead=False) -> int
        addChild(ASTNode self, ASTNode disownedChild) -> int


        Adds the given node as a child of this ASTNode.

        Child nodes are added in-order, from left to right.

        Parameter 'disownedChild' is the ASTNode instance to add

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        WARNING:

        Explicitly adding, removing or replacing children of an ASTNode object
        may change the structure of the mathematical formula it represents,
        and may even render the representation invalid.  Callers need to be
        careful to use this method in the context of other operations to
        create complete and correct formulas.  The method
        ASTNode.isWellFormedASTNode() may also be useful for checking the
        results of node modifications.

        See also prependChild(), replaceChild(), insertChild(), removeChild(),
        isWellFormedASTNode().

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        return _libsbml.ASTNode_addChild(self, disownedChild, inRead)


    def prependChild(self, disownedChild):
        """
        prependChild(ASTNode self, ASTNode disownedChild) -> int


        Adds the given node as a child of this ASTNode.  This method adds
        child nodes from right to left.

        Parameter 'disownedChild' is the ASTNode instance to add

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        WARNING:

        Explicitly adding, removing or replacing children of an ASTNode object
        may change the structure of the mathematical formula it represents,
        and may even render the representation invalid.  Callers need to be
        careful to use this method in the context of other operations to
        create complete and correct formulas.  The method
        ASTNode.isWellFormedASTNode() may also be useful for checking the
        results of node modifications.

        See also addChild(), replaceChild(), insertChild(), removeChild().

        """
        return _libsbml.ASTNode_prependChild(self, disownedChild)


    def removeChild(self, n):
        """
        removeChild(ASTNode self, unsigned int n) -> int


        Removes the nth child of this ASTNode object.

        Parameter 'n' is long the index of the child to remove

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INDEX_EXCEEDS_SIZE

        WARNING:

        Explicitly adding, removing or replacing children of an ASTNode object
        may change the structure of the mathematical formula it represents,
        and may even render the representation invalid.  Callers need to be
        careful to use this method in the context of other operations to
        create complete and correct formulas.  The method
        ASTNode.isWellFormedASTNode() may also be useful for checking the
        results of node modifications.

        See also addChild(), prependChild(), replaceChild(), insertChild().

        """
        return _libsbml.ASTNode_removeChild(self, n)


    def replaceChild(self, n, disownedChild, delreplaced=False):
        """
        replaceChild(ASTNode self, unsigned int n, ASTNode disownedChild, bool delreplaced=False) -> int
        replaceChild(ASTNode self, unsigned int n, ASTNode disownedChild) -> int


        Replaces and optionally deletes the nth child of this ASTNode with the
        given ASTNode.

        Parameter 'n' is long the index of the child to replace Parameter
        'disownedChild' is ASTNode to replace the nth child Parameter
        'delreplaced' is boolean indicating whether to delete the replaced
        child.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INDEX_EXCEEDS_SIZE

        * LIBSBML_INVALID_OBJECT

        WARNING:

        Explicitly adding, removing or replacing children of an ASTNode object
        may change the structure of the mathematical formula it represents,
        and may even render the representation invalid.  Callers need to be
        careful to use this method in the context of other operations to
        create complete and correct formulas.  The method
        ASTNode.isWellFormedASTNode() may also be useful for checking the
        results of node modifications.

        See also addChild(), prependChild(), insertChild(), removeChild().

        """
        return _libsbml.ASTNode_replaceChild(self, n, disownedChild, delreplaced)


    def insertChild(self, n, disownedChild):
        """
        insertChild(ASTNode self, unsigned int n, ASTNode disownedChild) -> int


        Inserts the given ASTNode at point n in the list of children of this
        ASTNode.

        Parameter 'n' is long the index of the ASTNode being added Parameter
        'disownedChild' is ASTNode to insert as the nth child

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INDEX_EXCEEDS_SIZE

        * LIBSBML_INVALID_OBJECT

        WARNING:

        Explicitly adding, removing or replacing children of an ASTNode object
        may change the structure of the mathematical formula it represents,
        and may even render the representation invalid.  Callers need to be
        careful to use this method in the context of other operations to
        create complete and correct formulas.  The method
        ASTNode.isWellFormedASTNode() may also be useful for checking the
        results of node modifications.

        See also addChild(), prependChild(), replaceChild(), removeChild().

        """
        return _libsbml.ASTNode_insertChild(self, n, disownedChild)


    def deepCopy(self):
        """
        deepCopy(ASTNode self) -> ASTNode


        Creates a recursive copy of this node and all its children.

        Returns a copy of this ASTNode and all its children.  The caller owns
        the returned ASTNode and is responsible for deleting it.

        """
        return _libsbml.ASTNode_deepCopy(self)


    def getChild(self, n):
        """
        getChild(ASTNode self, unsigned int n) -> ASTNode


        Gets a child of this node according to its index number.

        Parameter 'n' is the index of the child to get

        Returns the nth child of this ASTNode or 'None' if this node has no
        nth child (n >  ASTNode.getNumChildren() - 1).

        See also getNumChildren(), getLeftChild(), getRightChild().

        """
        return _libsbml.ASTNode_getChild(self, n)


    def getLeftChild(self):
        """
        getLeftChild(ASTNode self) -> ASTNode


        Gets the left child of this node.

        Returns the left child of this ASTNode.  This is equivalent to calling
        ASTNode.getChild() with an argument of '0.'

        See also getNumChildren(), getChild(), getRightChild().

        """
        return _libsbml.ASTNode_getLeftChild(self)


    def getRightChild(self):
        """
        getRightChild(ASTNode self) -> ASTNode


        Gets the right child of this node.

        Returns the right child of this ASTNode, or 'None' if this node has no
        right child.  If ASTNode.getNumChildren() > 1, then this is equivalent
        to:

          getChild( getNumChildren() - 1 );

        See also getNumChildren(), getLeftChild(), getChild().

        """
        return _libsbml.ASTNode_getRightChild(self)


    def getNumChildren(self):
        """
        getNumChildren(ASTNode self) -> unsigned int


        Gets the number of children that this node has.

        Returns the number of children of this ASTNode, or 0 is this node has
        no children.

        """
        return _libsbml.ASTNode_getNumChildren(self)


    def addSemanticsAnnotation(self, disownedAnnotation):
        """
        addSemanticsAnnotation(ASTNode self, XMLNode disownedAnnotation) -> int


        Adds the given XMLNode as a semantic annotation of this ASTNode.

        The <semantics> element is a MathML 2.0 construct that can be used to
        associate additional information with a MathML construct.  The
        construct can be used to decorate a MathML expressions with a sequence
        of one or more <annotation> or <annotation-xml> elements.  Each such
        element contains a pair of items; the first is a symbol that acts as
        an attribute or key, and the second is the value associated with the
        attribute or key.  Please refer to the MathML 2.0 documentation,
        particularly the Section 5.2, Semantic Annotations for more
        information about these constructs.

        Parameter 'disownedAnnotation' is the annotation to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        Note: Although SBML permits the semantic annotation construct in
        MathML expressions, the truth is that this construct has so far (at
        this time of this writing, which is early 2011) seen very little use
        in SBML software.  The full implications of using semantic annotations
        are still poorly understood.  If you wish to use this construct, we
        urge you to discuss possible uses and applications on the SBML
        discussion lists, particularly sbml-discuss@caltech.edu and/or sbml-
        interoperability@caltech.edu.

        """
        return _libsbml.ASTNode_addSemanticsAnnotation(self, disownedAnnotation)


    def getNumSemanticsAnnotations(self):
        """
        getNumSemanticsAnnotations(ASTNode self) -> unsigned int


        Gets the number of semantic annotation elements inside this node.

        The <semantics> element is a MathML 2.0 construct that can be used to
        associate additional information with a MathML construct.  The
        construct can be used to decorate a MathML expressions with a sequence
        of one or more <annotation> or <annotation-xml> elements.  Each such
        element contains a pair of items; the first is a symbol that acts as
        an attribute or key, and the second is the value associated with the
        attribute or key.  Please refer to the MathML 2.0 documentation,
        particularly the Section 5.2, Semantic Annotations for more
        information about these constructs.

        Returns the number of annotations of this ASTNode.

        See also ASTNode.addSemanticsAnnotation().

        """
        return _libsbml.ASTNode_getNumSemanticsAnnotations(self)


    def getSemanticsAnnotation(self, n):
        """
        getSemanticsAnnotation(ASTNode self, unsigned int n) -> XMLNode


        Gets the nth semantic annotation of this node.

        The <semantics> element is a MathML 2.0 construct that can be used to
        associate additional information with a MathML construct.  The
        construct can be used to decorate a MathML expressions with a sequence
        of one or more <annotation> or <annotation-xml> elements.  Each such
        element contains a pair of items; the first is a symbol that acts as
        an attribute or key, and the second is the value associated with the
        attribute or key.  Please refer to the MathML 2.0 documentation,
        particularly the Section 5.2, Semantic Annotations for more
        information about these constructs.

        Returns the nth annotation of this ASTNode, or 'None' if this node has
        no nth annotation (n > ASTNode.getNumSemanticsAnnotations() - 1).

        See also ASTNode.addSemanticsAnnotation().

        """
        return _libsbml.ASTNode_getSemanticsAnnotation(self, n)


    def getCharacter(self):
        """
        getCharacter(ASTNode self) -> char


        Gets the value of this node as a single character.

        This function should be called only when ASTNode.getType() returns
        AST_PLUS, AST_MINUS, AST_TIMES, AST_DIVIDE or AST_POWER.

        Returns the value of this ASTNode as a single character

        """
        return _libsbml.ASTNode_getCharacter(self)


    def getId(self):
        """
        getId(ASTNode self) -> string


        Gets the id of this ASTNode.

        Returns the MathML id of this ASTNode.

        """
        return _libsbml.ASTNode_getId(self)


    def getClass(self):
        """
        getClass(ASTNode self) -> string


        Gets the class of this ASTNode.

        Returns the MathML class of this ASTNode.

        """
        return _libsbml.ASTNode_getClass(self)


    def getStyle(self):
        """
        getStyle(ASTNode self) -> string


        Gets the style of this ASTNode.

        Returns the MathML style of this ASTNode.

        """
        return _libsbml.ASTNode_getStyle(self)


    def getInteger(self):
        """
        getInteger(ASTNode self) -> long


        Gets the value of this node as an integer.

        This function should be called only when ASTNode.getType() ==
        AST_INTEGER.

        Returns the value of this ASTNode as a (long) integer.

        """
        return _libsbml.ASTNode_getInteger(self)


    def getName(self):
        """
        getName(ASTNode self) -> char const *


        Gets the value of this node as a string.

        This function may be called on nodes that (1) are not operators, i.e.,
        nodes for which ASTNode.isOperator() returns 'False,' and (2) are not
        numbers, i.e., ASTNode.isNumber() returns 'False.'

        Returns the value of this ASTNode as a string.

        """
        return _libsbml.ASTNode_getName(self)


    def getOperatorName(self):
        """
        getOperatorName(ASTNode self) -> char const *


        Gets the value of this operator node as a string.  This function may
        be called on nodes that are operators, i.e., nodes for which
        ASTNode.isOperator() returns 'True.'

        Returns the name of this operator ASTNode as a string (or None if not
        an operator).

        """
        return _libsbml.ASTNode_getOperatorName(self)


    def getNumerator(self):
        """
        getNumerator(ASTNode self) -> long


        Gets the value of the numerator of this node.  This function should be
        called only when ASTNode.getType() == AST_RATIONAL.

        Returns the value of the numerator of this ASTNode.

        """
        return _libsbml.ASTNode_getNumerator(self)


    def getDenominator(self):
        """
        getDenominator(ASTNode self) -> long


        Gets the value of the denominator of this node.  This function should
        be called only when ASTNode.getType() == AST_RATIONAL.

        Returns the value of the denominator of this ASTNode.

        """
        return _libsbml.ASTNode_getDenominator(self)


    def getReal(self):
        """
        getReal(ASTNode self) -> double


        Gets the real-numbered value of this node.  This function should be
        called only when ASTNode.isReal() == true.

        This function performs the necessary arithmetic if the node type is
        AST_REAL_E (mantissa * 10^exponent) or AST_RATIONAL (numerator /
        denominator).

        Returns the value of this ASTNode as a real (double).

        """
        return _libsbml.ASTNode_getReal(self)


    def getMantissa(self):
        """
        getMantissa(ASTNode self) -> double


        Gets the mantissa value of this node.  This function should be called
        only when ASTNode.getType() returns AST_REAL_E or AST_REAL. If
        ASTNode.getType() returns AST_REAL, this method is identical to
        ASTNode.getReal().

        Returns the value of the mantissa of this ASTNode.

        """
        return _libsbml.ASTNode_getMantissa(self)


    def getExponent(self):
        """
        getExponent(ASTNode self) -> long


        Gets the exponent value of this ASTNode.  This function should be
        called only when ASTNode.getType() returns AST_REAL_E or AST_REAL.

        Returns the value of the exponent of this ASTNode.

        """
        return _libsbml.ASTNode_getExponent(self)


    def getValue(self):
        """
        getValue(ASTNode self) -> double


        Returns the numerical value of this ASTNode.

        Returns the numerical value of this ASTNode, or 'NaN' if this is not a
        type of node that has a numerical value.

        Note: This function will return a numerical value (as a double) for
        any ASTNode_t that represents a number, a constant such as
        AST_CONSTANT_PI,  AST_CONSTANT_E, or  AST_NAME_AVOGADRO, or  '1' for
        nodes of type  AST_CONSTANT_TRUE and '0' for nodes of type
        AST_CONSTANT_FALSE. It does not evaluate the node in any way so, for
        example, it will not return the value of  a named ASTNode_t or attempt
        to evaluate a function.  This includes a node representing 'time' i.e.
        nodes of type AST_NAME_TIME.

        """
        return _libsbml.ASTNode_getValue(self)


    def getPrecedence(self):
        """
        getPrecedence(ASTNode self) -> int


        Gets the precedence of this node in the infix math syntax of SBML
        Level 1.  For more information about the infix syntax, see the
        discussion about text string formulas at the top of the documentation
        for ASTNode.

        Returns an integer indicating the precedence of this ASTNode

        """
        return _libsbml.ASTNode_getPrecedence(self)


    def getType(self):
        """
        getType(ASTNode self) -> ASTNodeType_t


        Gets the type of this ASTNode.  The value returned is one of the
        enumeration values such as AST_LAMBDA, AST_PLUS, etc.

        Returns the type of this ASTNode.

        """
        return _libsbml.ASTNode_getType(self)


    def getUnits(self):
        """
        getUnits(ASTNode self) -> string


        Gets the units of this ASTNode.

        SBML Level 3 Version 1 introduced the ability to include an attribute
        sbml:units on MathML cn elements appearing in SBML mathematical
        formulas.  The value of this attribute can be used to indicate the
        unit of measurement to be associated with the number in the content of
        the cn element.  The value of this attribute must be the identifier of
        a unit of measurement defined by SBML or the enclosing Model.  Here,
        the sbml portion is an XML namespace prefix that must be associated
        with the SBML namespace for SBML Level 3.  The following example
        illustrates how this attribute can be used to define a number with
        value 10 and unit of measurement second:

          <math xmlns="http://www.w3.org/1998/Math/MathML"
                xmlns:sbml="http://www.sbml.org/sbml/level3/version1/core">
                  <cn type="integer" sbml:units="second"> 10 </cn>
          </math>

        Returns the units of this ASTNode.

        Note: The sbml:units attribute is only available in SBML Level 3.  It
        may not be used in Levels 1-2 of SBML.

        See also libsbml.parseL3Formula().

        """
        return _libsbml.ASTNode_getUnits(self)


    def isAvogadro(self):
        """
        isAvogadro(ASTNode self) -> bool


        Returns 'True' (non-zero) if this node is the special  symbol
        'avogadro.'  The predicate returns 'False' (zero) otherwise.

        Returns 'True' if this ASTNode is the special symbol avogadro.

        See also libsbml.parseL3Formula().

        """
        return _libsbml.ASTNode_isAvogadro(self)


    def isBoolean(self):
        """
        isBoolean(ASTNode self) -> bool


        Returns 'True' (non-zero) if this node has a boolean type (a logical
        operator, a relational operator, or the constants 'True' or 'False).'

        Returns true if this ASTNode is a boolean, false otherwise.

        """
        return _libsbml.ASTNode_isBoolean(self)


    def returnsBoolean(self, model=None):
        """
        returnsBoolean(ASTNode self, Model model=None) -> bool
        returnsBoolean(ASTNode self) -> bool


        Returns 'True' (non-zero) if this node returns a boolean type or
        'False' (zero) otherwise.

        This function looks at the whole ASTNode rather than just the top
        level of the ASTNode. Thus it will consider return values from
        piecewise statements.  In addition, if this ASTNode uses a function
        call, the return value of the functionDefinition will be determined.
        Note that this is only possible where the ASTNode can trace its parent
        Model, that is, the ASTNode must represent the math element of some
        SBML object that has already been added to an instance of an
        SBMLDocument.

        See also isBoolean().

        Returns true if this ASTNode returns a boolean, false otherwise.

        """
        return _libsbml.ASTNode_returnsBoolean(self, model)


    def isConstant(self):
        """
        isConstant(ASTNode self) -> bool


        Returns 'True' (non-zero) if this node represents a MathML constant
        (e.g., 'True,' 'Pi).'

        Returns 'True' if this ASTNode is a MathML constant, 'False'
        otherwise.

        Note: this function will also return 'True' for AST_NAME_AVOGADRO in
        SBML Level 3.

        """
        return _libsbml.ASTNode_isConstant(self)


    def isCiNumber(self):
        """
        isCiNumber(ASTNode self) -> bool


        Returns 'True' (non-zero) if this node represents a MathML ci element
        representing a value not a function (e.g., 'True,' 'Pi).'

        Returns 'True' if this ASTNode is a MathML ci element, 'False'
        otherwise.

        """
        return _libsbml.ASTNode_isCiNumber(self)


    def isConstantNumber(self):
        """
        isConstantNumber(ASTNode self) -> bool


        Returns 'True' (non-zero) if this node represents a MathML constant
        with numeric value(e.g., 'Pi).'

        Returns 'True' if this ASTNode is a MathML constant, 'False'
        otherwise.

        Note: this function will also return 'True' for AST_NAME_AVOGADRO in
        SBML Level 3.

        """
        return _libsbml.ASTNode_isConstantNumber(self)


    def isCSymbolFunction(self):
        """
        isCSymbolFunction(ASTNode self) -> bool


        Returns 'True' (non-zero) if this node represents a MathML csymbol
        representing a function.

        Returns 'True' if this ASTNode is a MathML csymbol function, 'False'
        otherwise.

        """
        return _libsbml.ASTNode_isCSymbolFunction(self)


    def isFunction(self):
        """
        isFunction(ASTNode self) -> bool


        Returns 'True' (non-zero) if this node represents a MathML function
        (e.g., abs()), or an SBML Level 1 function, or a user-defined
        function.

        Returns 'True' if this ASTNode is a function, 'False' otherwise.

        """
        return _libsbml.ASTNode_isFunction(self)


    def isInfinity(self):
        """
        isInfinity(ASTNode self) -> bool


        Returns 'True' (non-zero) if this node represents the special IEEE 754
        value infinity, 'False' (zero) otherwise.

        Returns 'True' if this ASTNode is the special IEEE 754 value infinity,
        'False' otherwise.

        """
        return _libsbml.ASTNode_isInfinity(self)


    def isInteger(self):
        """
        isInteger(ASTNode self) -> bool


        Returns 'True' (non-zero) if this node contains an integer value,
        'False' (zero) otherwise.

        Returns 'True' if this ASTNode is of type AST_INTEGER, 'False'
        otherwise.

        """
        return _libsbml.ASTNode_isInteger(self)


    def isLambda(self):
        """
        isLambda(ASTNode self) -> bool


        Returns 'True' (non-zero) if this node is a MathML <lambda>, 'False'
        (zero) otherwise.

        Returns 'True' if this ASTNode is of type AST_LAMBDA, 'False'
        otherwise.

        """
        return _libsbml.ASTNode_isLambda(self)


    def isLog10(self):
        """
        isLog10(ASTNode self) -> bool


        Returns 'True' (non-zero) if this node represents a  'log10' function,
        'False' (zero) otherwise.  More precisely, this predicate returns
        'True' if the node type is AST_FUNCTION_LOG with two children, the
        first of which is an AST_INTEGER equal to 10.

        Returns 'True' if the given ASTNode represents a log10() function,
        'False' otherwise.

        See also libsbml.parseL3Formula().

        """
        return _libsbml.ASTNode_isLog10(self)


    def isLogical(self):
        """
        isLogical(ASTNode self) -> bool


        Returns 'True' (non-zero) if this node is a MathML logical operator
        (i.e., 'and,' 'or,' 'not,' 'xor).'

        Returns 'True' if this ASTNode is a MathML logical operator

        """
        return _libsbml.ASTNode_isLogical(self)


    def isName(self):
        """
        isName(ASTNode self) -> bool


        Returns 'True' (non-zero) if this node is a user-defined variable name
        in SBML L1, L2 (MathML), or the special symbols 'time' or 'avogadro.'
        The predicate returns 'False' (zero) otherwise.

        Returns 'True' if this ASTNode is a user-defined variable name in SBML
        L1, L2 (MathML) or the special symbols delay or time.

        """
        return _libsbml.ASTNode_isName(self)


    def isNaN(self):
        """
        isNaN(ASTNode self) -> bool


        Returns 'True' (non-zero) if this node represents the special IEEE 754
        value 'not a number' (NaN), 'False' (zero) otherwise.

        Returns 'True' if this ASTNode is the special IEEE 754 NaN.

        """
        return _libsbml.ASTNode_isNaN(self)


    def isNegInfinity(self):
        """
        isNegInfinity(ASTNode self) -> bool


        Returns 'True' (non-zero) if this node represents the special IEEE 754
        value 'negative infinity', 'False' (zero) otherwise.

        Returns 'True' if this ASTNode is the special IEEE 754 value negative
        infinity, 'False' otherwise.

        """
        return _libsbml.ASTNode_isNegInfinity(self)


    def isNumber(self):
        """
        isNumber(ASTNode self) -> bool


        Returns 'True' (non-zero) if this node contains a number, 'False'
        (zero) otherwise.  This is functionally equivalent to the following
        code:

           isInteger() || isReal()

        Returns 'True' if this ASTNode is a number, 'False' otherwise.

        """
        return _libsbml.ASTNode_isNumber(self)


    def isOperator(self):
        """
        isOperator(ASTNode self) -> bool


        Returns 'True' (non-zero) if this node is a mathematical operator,
        meaning, +, -, *,  / or ^ (power).

        Returns 'True' if this ASTNode is an operator.

        """
        return _libsbml.ASTNode_isOperator(self)


    def isPiecewise(self):
        """
        isPiecewise(ASTNode self) -> bool


        Returns 'True' (non-zero) if this node is the MathML <piecewise>
        construct, 'False' (zero) otherwise.

        Returns 'True' if this ASTNode is a MathML 'piecewise' function

        """
        return _libsbml.ASTNode_isPiecewise(self)


    def isRational(self):
        """
        isRational(ASTNode self) -> bool


        Returns 'True' (non-zero) if this node represents a rational number,
        'False' (zero) otherwise.

        Returns 'True' if this ASTNode is of type AST_RATIONAL.

        """
        return _libsbml.ASTNode_isRational(self)


    def isReal(self):
        """
        isReal(ASTNode self) -> bool


        Returns 'True' (non-zero) if this node can represent a real number,
        'False' (zero) otherwise.

        More precisely, this node must be of one of the following types:
        AST_REAL, AST_REAL_E or AST_RATIONAL.

        Returns 'True' if the value of this ASTNode can represented as a real
        number, 'False' otherwise.

        """
        return _libsbml.ASTNode_isReal(self)


    def isRelational(self):
        """
        isRelational(ASTNode self) -> bool


        Returns 'True' (non-zero) if this node is a MathML relational
        operator, meaning ==, >=, >, <, and !=.

        Returns 'True' if this ASTNode is a MathML relational operator,
        'False' otherwise

        """
        return _libsbml.ASTNode_isRelational(self)


    def isSqrt(self):
        """
        isSqrt(ASTNode self) -> bool


        Returns 'True' (non-zero) if this node represents a square root
        function, 'False' (zero) otherwise.

        More precisely, the node type must be AST_FUNCTION_ROOT with two
        children, the first of which is an AST_INTEGER node having value equal
        to 2.

        Returns 'True' if the given ASTNode represents a sqrt() function,
        'False' otherwise.

        """
        return _libsbml.ASTNode_isSqrt(self)


    def isUMinus(self):
        """
        isUMinus(ASTNode self) -> bool


        Returns 'True' (non-zero) if this node is a unary minus operator,
        'False' (zero) otherwise.

        A node is defined as a unary minus node if it is of type AST_MINUS and
        has exactly one child.

        For numbers, unary minus nodes can be 'collapsed' by negating the
        number.  In fact,  libsbml.parseFormula() does this during its parsing
        process, and  libsbml.parseL3Formula() has a configuration option that
        allows this behavior to be turned on or off.  However, unary minus
        nodes for symbols (AST_NAME) cannot be 'collapsed', so this predicate
        function is necessary.

        Returns 'True' if this ASTNode is a unary minus, 'False' otherwise.

        See also libsbml.parseL3Formula().

        """
        return _libsbml.ASTNode_isUMinus(self)


    def isUPlus(self):
        """
        isUPlus(ASTNode self) -> bool


        Returns 'True' (non-zero) if this node is a unary plus operator,
        'False' (zero) otherwise.  A node is defined as a unary minus node if
        it is of type AST_MINUS and has exactly one child.

        Returns 'True' if this ASTNode is a unary plus, 'False' otherwise.

        """
        return _libsbml.ASTNode_isUPlus(self)


    def isUserFunction(self):
        """
        isUserFunction(ASTNode self) -> bool


        Returns 'True' (non-zero) if this node represents a MathML user-
        defined function.

        Returns 'True' if this ASTNode is a user-defined function, 'False'
        otherwise.

        """
        return _libsbml.ASTNode_isUserFunction(self)


    def hasTypeAndNumChildren(self, type, numchildren):
        """
        hasTypeAndNumChildren(ASTNode self, ASTNodeType_t type, unsigned int numchildren) -> int


        Returns 'True' if this node is of type Parameter 'type' is and has
        Parameter 'numchildren' is number of children.  Designed for use in
        cases where it is useful to discover if the node is a unary not or
        unary minus, or a times node with no children, etc.

        Returns 'True' if this ASTNode is has the specified type and number of
        children, 'False' otherwise.

        """
        return _libsbml.ASTNode_hasTypeAndNumChildren(self, type, numchildren)


    def isUnknown(self):
        """
        isUnknown(ASTNode self) -> bool


        Returns 'True' (non-zero) if this node has an unknown type.

        'Unknown' nodes have the type AST_UNKNOWN.  Nodes with unknown types
        will not appear in an ASTNode tree returned by libSBML based upon
        valid SBML input; the only situation in which a node with type
        AST_UNKNOWN may appear is immediately after having create a new,
        untyped node using the ASTNode constructor.  Callers creating nodes
        should endeavor to set the type to a valid node type as soon as
        possible after creating new nodes.

        Returns 'True' if this ASTNode is of type AST_UNKNOWN, 'False'
        otherwise.

        """
        return _libsbml.ASTNode_isUnknown(self)


    def isSetId(self):
        """
        isSetId(ASTNode self) -> bool


        Returns 'True' (non-zero) if this node has a value for the MathML
        attribute 'id'.

        Returns true if this ASTNode has an attribute id, false otherwise.

        """
        return _libsbml.ASTNode_isSetId(self)


    def isSetClass(self):
        """
        isSetClass(ASTNode self) -> bool


        Returns 'True' (non-zero) if this node has a value for the MathML
        attribute 'class'.

        Returns true if this ASTNode has an attribute class, false otherwise.

        """
        return _libsbml.ASTNode_isSetClass(self)


    def isSetStyle(self):
        """
        isSetStyle(ASTNode self) -> bool


        Returns 'True' (non-zero) if this node has a value for the MathML
        attribute 'style'.

        Returns true if this ASTNode has an attribute style, false otherwise.

        """
        return _libsbml.ASTNode_isSetStyle(self)


    def isSetUnits(self):
        """
        isSetUnits(ASTNode self) -> bool


        Returns 'True' (non-zero) if this node has the attribute sbml:units.

        SBML Level 3 Version 1 introduced the ability to include an attribute
        sbml:units on MathML cn elements appearing in SBML mathematical
        formulas.  The value of this attribute can be used to indicate the
        unit of measurement to be associated with the number in the content of
        the cn element.  The value of this attribute must be the identifier of
        a unit of measurement defined by SBML or the enclosing Model.  Here,
        the sbml portion is an XML namespace prefix that must be associated
        with the SBML namespace for SBML Level 3.  The following example
        illustrates how this attribute can be used to define a number with
        value 10 and unit of measurement second:

          <math xmlns="http://www.w3.org/1998/Math/MathML"
                xmlns:sbml="http://www.sbml.org/sbml/level3/version1/core">
                  <cn type="integer" sbml:units="second"> 10 </cn>
          </math>

        Returns 'True' if this ASTNode has units associated with it, 'False'
        otherwise.

        Note: The sbml:units attribute is only available in SBML Level 3.  It
        may not be used in Levels 1-2 of SBML.

        """
        return _libsbml.ASTNode_isSetUnits(self)


    def hasUnits(self):
        """
        hasUnits(ASTNode self) -> bool


        Returns 'True' (non-zero) if this node or any of its children nodes
        have the attribute sbml:units.

        SBML Level 3 Version 1 introduced the ability to include an attribute
        sbml:units on MathML cn elements appearing in SBML mathematical
        formulas.  The value of this attribute can be used to indicate the
        unit of measurement to be associated with the number in the content of
        the cn element.  The value of this attribute must be the identifier of
        a unit of measurement defined by SBML or the enclosing Model.  Here,
        the sbml portion is an XML namespace prefix that must be associated
        with the SBML namespace for SBML Level 3.  The following example
        illustrates how this attribute can be used to define a number with
        value 10 and unit of measurement second:

          <math xmlns="http://www.w3.org/1998/Math/MathML"
                xmlns:sbml="http://www.sbml.org/sbml/level3/version1/core">
                  <cn type="integer" sbml:units="second"> 10 </cn>
          </math>

        Returns 'True' if this ASTNode or its children has units associated
        with it, 'False' otherwise.

        Note: The sbml:units attribute is only available in SBML Level 3.  It
        may not be used in Levels 1-2 of SBML.

        """
        return _libsbml.ASTNode_hasUnits(self)


    def setCharacter(self, value):
        """
        setCharacter(ASTNode self, char value) -> int


        Sets the value of this ASTNode to the given character.  If character
        is one of '+,' '-,' *, / or '^,' the node type will be set
        accordingly.  For all other characters, the node type will be set to
        AST_UNKNOWN.

        Parameter 'value' is the character value to which the node's value
        should be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.ASTNode_setCharacter(self, value)


    def setId(self, id):
        """
        setId(ASTNode self, string id) -> int


        Sets the MathML id of this ASTNode to id.

        Parameter 'id' is 'string' representing the identifier.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.ASTNode_setId(self, id)


    def setClass(self, className):
        """
        setClass(ASTNode self, string className) -> int


        Sets the MathML class of this ASTNode to className.

        Parameter 'className' is 'string' representing the MathML class for
        this node.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.ASTNode_setClass(self, className)


    def setStyle(self, style):
        """
        setStyle(ASTNode self, string style) -> int


        Sets the MathML style of this ASTNode to style.

        Parameter 'style' is 'string' representing the identifier.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.ASTNode_setStyle(self, style)


    def setName(self, name):
        """
        setName(ASTNode self, char const * name) -> int


        Sets the value of this ASTNode to the given name.

        As a side-effect, this ASTNode object's type will be reset to AST_NAME
        if (and only if) the ASTNode was previously an operator (
        ASTNode.isOperator() == true), number ( ASTNode.isNumber() == true),
        or unknown. This allows names to be set for AST_FUNCTION nodes and the
        like.

        Parameter 'name' is the string containing the name to which this
        node's value should be set

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.ASTNode_setName(self, name)


    def setValue(self, *args):
        """
        setValue(ASTNode self, long value) -> int
        setValue(ASTNode self, long numerator, long denominator) -> int
        setValue(ASTNode self, double value) -> int
        setValue(ASTNode self, double mantissa, long exponent) -> int


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            setValue(long numerator, long denominator)

        Sets the value of this ASTNode to the given rational in two parts: the
        numerator and denominator.  The node type is set to AST_RATIONAL.

        Parameter 'numerator' is the numerator value of the rational Parameter
        'denominator' is the denominator value of the rational

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        ______________________________________________________________________
        Method variant with the following signature:

            setValue(double mantissa, long exponent)

        Sets the value of this ASTNode to the given real ('float)' in two
        parts: the mantissa and the exponent.  The node type is set to
        AST_REAL_E.

        Parameter 'mantissa' is the mantissa of this node's real-numbered
        value Parameter 'exponent' is the exponent of this node's real-
        numbered value

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        ______________________________________________________________________
        Method variant with the following signature:

            setValue(int value)

        Sets the value of this ASTNode to the given integer and sets the node
        type to AST_INTEGER.

        Parameter 'value' is the integer to which this node's value should be
        set

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        ______________________________________________________________________
        Method variant with the following signature:

            setValue(double value)

        Sets the value of this ASTNode to the given real ('float)' and sets
        the node type to AST_REAL.

        This is functionally equivalent to:

          setValue(value, 0);

        Parameter 'value' is the 'float' format number to which this node's
        value should be set

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        ______________________________________________________________________
        Method variant with the following signature:

            setValue(long value)

        Sets the value of this ASTNode to the given ('long)' integer and sets
        the node type to AST_INTEGER.

        Parameter 'value' is the integer to which this node's value should be
        set

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.ASTNode_setValue(self, *args)


    def setType(self, type):
        """
        setType(ASTNode self, ASTNodeType_t type) -> int


        Sets the type of this ASTNode to the given type code.

        Parameter 'type' is the type to which this node should be set

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        Note: A side-effect of doing this is that any numerical values
        previously stored in this node are reset to zero.

        """
        return _libsbml.ASTNode_setType(self, type)


    def setUnits(self, units):
        """
        setUnits(ASTNode self, string units) -> int


        Sets the units of this ASTNode to units.

        The units will be set only if this ASTNode object represents a MathML
        <cn> element, i.e., represents a number. Callers may use
        ASTNode.isNumber() to inquire whether the node is of that type.

        SBML Level 3 Version 1 introduced the ability to include an attribute
        sbml:units on MathML cn elements appearing in SBML mathematical
        formulas.  The value of this attribute can be used to indicate the
        unit of measurement to be associated with the number in the content of
        the cn element.  The value of this attribute must be the identifier of
        a unit of measurement defined by SBML or the enclosing Model.  Here,
        the sbml portion is an XML namespace prefix that must be associated
        with the SBML namespace for SBML Level 3.  The following example
        illustrates how this attribute can be used to define a number with
        value 10 and unit of measurement second:

          <math xmlns="http://www.w3.org/1998/Math/MathML"
                xmlns:sbml="http://www.sbml.org/sbml/level3/version1/core">
                  <cn type="integer" sbml:units="second"> 10 </cn>
          </math>

        Parameter 'units' is 'string' representing the unit identifier.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        Note: The sbml:units attribute is only available in SBML Level 3.  It
        may not be used in Levels 1-2 of SBML.

        """
        return _libsbml.ASTNode_setUnits(self, units)


    def swapChildren(self, that):
        """
        swapChildren(ASTNode self, ASTNode that) -> int


        Swaps the children of this ASTNode object with the children of the
        given ASTNode object.

        Parameter 'that' is the other node whose children should be used to
        replace this node's children

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.ASTNode_swapChildren(self, that)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(ASTNode self, string oldid, string newid)


        Renames all the SIdRef attributes on this node and any child node

        """
        return _libsbml.ASTNode_renameSIdRefs(self, oldid, newid)


    def renameUnitSIdRefs(self, oldid, newid):
        """
        renameUnitSIdRefs(ASTNode self, string oldid, string newid)


        Renames all the UnitSIdRef attributes on this node and any child node.
        (The only place UnitSIDRefs appear in MathML <cn> elements.)

        """
        return _libsbml.ASTNode_renameUnitSIdRefs(self, oldid, newid)


    def replaceIDWithFunction(self, id, function):
        """
        replaceIDWithFunction(ASTNode self, string id, ASTNode function)


        Internal implementation method.

        """
        return _libsbml.ASTNode_replaceIDWithFunction(self, id, function)


    def multiplyTimeBy(self, function):
        """
        multiplyTimeBy(ASTNode self, ASTNode function)


        Internal implementation method.

        """
        return _libsbml.ASTNode_multiplyTimeBy(self, function)


    def unsetUnits(self):
        """
        unsetUnits(ASTNode self) -> int


        Unsets the units of this ASTNode.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.ASTNode_unsetUnits(self)


    def unsetId(self):
        """
        unsetId(ASTNode self) -> int


        Unsets the MathML id of this ASTNode.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.ASTNode_unsetId(self)


    def unsetClass(self):
        """
        unsetClass(ASTNode self) -> int


        Unsets the MathML class of this ASTNode.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.ASTNode_unsetClass(self)


    def unsetStyle(self):
        """
        unsetStyle(ASTNode self) -> int


        Unsets the MathML style of this ASTNode.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.ASTNode_unsetStyle(self)


    def setDefinitionURL(self, *args):
        """
        setDefinitionURL(ASTNode self, XMLAttributes url) -> int
        setDefinitionURL(ASTNode self, string url) -> int
        """
        return _libsbml.ASTNode_setDefinitionURL(self, *args)


    def getDefinitionURL(self):
        """
        getDefinitionURL(ASTNode self) -> XMLAttributes


        Gets the MathML 'definitionURL' attribute value.

        Returns the value of the 'definitionURL' attribute, in the form of a
        libSBML XMLAttributes object.

        """
        return _libsbml.ASTNode_getDefinitionURL(self)


    def replaceArgument(self, bvar, arg):
        """
        replaceArgument(ASTNode self, string bvar, ASTNode arg)


        Replaces occurences of a given name within this ASTNode with the
        name/value/formula represented by 'arg'.

        For example, if the formula in this ASTNode is x + y, then the <bvar>
        is 'x' and 'arg' is an ASTNode representing the real value '3.'  This
        method substitutes '3' for 'x' within this ASTNode object.

        Parameter 'bvar' is a string representing the variable name to be
        substituted Parameter 'arg' is an ASTNode representing the
        name/value/formula to substitute

        """
        return _libsbml.ASTNode_replaceArgument(self, bvar, arg)


    def getParentSBMLObject(self):
        """
        getParentSBMLObject(ASTNode self) -> SBase


        Returns the parent SBML object.

        Returns the parent SBML object of this ASTNode.

        """
        return _libsbml.ASTNode_getParentSBMLObject(self)


    def unsetParentSBMLObject(self):
        """
        unsetParentSBMLObject(ASTNode self) -> int


        Unsets the parent SBML object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also isSetParentSBMLObject(), getParentSBMLObject().

        """
        return _libsbml.ASTNode_unsetParentSBMLObject(self)


    def isSetParentSBMLObject(self):
        """
        isSetParentSBMLObject(ASTNode self) -> bool


        Returns 'True' if this node has a value for the parent SBML object.

        Returns true if this ASTNode has an parent SBML object set, 'False'
        otherwise.

        See also getParentSBMLObject().

        """
        return _libsbml.ASTNode_isSetParentSBMLObject(self)


    def reduceToBinary(self):
        """
        reduceToBinary(ASTNode self)


        Reduces this ASTNode to a binary tree.

        Example: if this ASTNode is and(x, y, z), then the  formula of the
        reduced node is and(and(x, y), z).  The operation replaces the formula
        stored in the current ASTNode object.

        """
        return _libsbml.ASTNode_reduceToBinary(self)


    def unsetUserData(self):
        """
        unsetUserData(ASTNode self) -> int


        Unsets the user data of this node.

        The user data can be used by the application developer to attach
        custom information to the node.  In case of a deep copy, this
        attribute will passed as it is. The attribute will be never
        interpreted by this class.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.ASTNode_unsetUserData(self)


    def isSetUserData(self):
        """
        isSetUserData(ASTNode self) -> bool


        Returns 'True' if this node has a user data object.

        Returns true if this ASTNode has a user data object set, 'False'
        otherwise.

        """
        return _libsbml.ASTNode_isSetUserData(self)


    def isWellFormedASTNode(self):
        """
        isWellFormedASTNode(ASTNode self) -> bool


        Returns 'True' or 'False' depending on whether this ASTNode is well-
        formed.

        Note: An ASTNode may be well-formed, with each node and its children
        having the appropriate number of children for the given type, but may
        still be invalid in the context of its use within an SBML model.

        Returns 'True' if this ASTNode is well-formed, 'False' otherwise.

        See also hasCorrectNumberArguments().

        """
        return _libsbml.ASTNode_isWellFormedASTNode(self)


    def hasCorrectNumberArguments(self):
        """
        hasCorrectNumberArguments(ASTNode self) -> bool


        Returns 'True' or 'False' depending on whether this ASTNode has the
        correct number of children for its type.

        For example, an ASTNode with type AST_PLUS expects 2 child nodes.

        Note: This function performs a check on the top-level node only.
        Child nodes are not checked.

        Returns 'True' if this ASTNode has the appropriate number of children
        for its type, 'False' otherwise.

        See also isWellFormedASTNode().

        """
        return _libsbml.ASTNode_hasCorrectNumberArguments(self)


    def getDefinitionURLString(self):
        """
        getDefinitionURLString(ASTNode self) -> string


        Returns the MathML 'definitionURL' attribute value as a string.

        Returns the value of the 'definitionURL' attribute, as a string.

        See also getDefinitionURL(), setDefinitionURL(), setDefinitionURL().

        """
        return _libsbml.ASTNode_getDefinitionURLString(self)


    def representsBvar(self):
        """
        representsBvar(ASTNode self) -> bool


        Internal implementation method.

        """
        return _libsbml.ASTNode_representsBvar(self)


    def isBvar(self):
        """
        isBvar(ASTNode self) -> bool


        Internal implementation method.

        """
        return _libsbml.ASTNode_isBvar(self)


    def setBvar(self):
        """
        setBvar(ASTNode self)


        Internal implementation method.

        """
        return _libsbml.ASTNode_setBvar(self)


    def usesL3V2MathConstructs(self):
        """
        usesL3V2MathConstructs(ASTNode self) -> bool


        Internal implementation method.

        """
        return _libsbml.ASTNode_usesL3V2MathConstructs(self)


    def usesRateOf(self):
        """
        usesRateOf(ASTNode self) -> bool


        Internal implementation method.

        """
        return _libsbml.ASTNode_usesRateOf(self)


    def isQualifier(self):
        """
        isQualifier(ASTNode self) -> bool


        Internal implementation method.

        """
        return _libsbml.ASTNode_isQualifier(self)


    def isSemantics(self):
        """
        isSemantics(ASTNode self) -> bool


        Internal implementation method.

        """
        return _libsbml.ASTNode_isSemantics(self)


    def getNumBvars(self):
        """
        getNumBvars(ASTNode self) -> unsigned int


        Internal implementation method.

        """
        return _libsbml.ASTNode_getNumBvars(self)


    def addPlugin(self, plugin):
        """
        addPlugin(ASTNode self, ASTBasePlugin plugin)


        Internal implementation method.

        """
        return _libsbml.ASTNode_addPlugin(self, plugin)


    def loadASTPlugins(self, sbmlns):
        """
        loadASTPlugins(ASTNode self, SBMLNamespaces sbmlns)


        Internal implementation method.

        """
        return _libsbml.ASTNode_loadASTPlugins(self, sbmlns)


    def loadASTPlugin(self, pkgName):
        """
        loadASTPlugin(ASTNode self, string pkgName)


        Internal implementation method.

        """
        return _libsbml.ASTNode_loadASTPlugin(self, pkgName)


    def getASTPlugin(self, *args):
        """
        getASTPlugin(ASTNode self, SBMLNamespaces sbmlns) -> ASTBasePlugin
        getASTPlugin(ASTNode self, ASTNodeType_t type) -> ASTBasePlugin
        getASTPlugin(ASTNode self, string name, bool isCsymbol=False, bool strCmpIsCaseSensitive=False) -> ASTBasePlugin
        getASTPlugin(ASTNode self, string name, bool isCsymbol=False) -> ASTBasePlugin
        getASTPlugin(ASTNode self, string name) -> ASTBasePlugin
        getASTPlugin(ASTNode self, SBMLNamespaces sbmlns) -> ASTBasePlugin
        getASTPlugin(ASTNode self, ASTNodeType_t type) -> ASTBasePlugin
        getASTPlugin(ASTNode self, string name, bool isCsymbol=False, bool strCmpIsCaseSensitive=False) -> ASTBasePlugin
        getASTPlugin(ASTNode self, string name, bool isCsymbol=False) -> ASTBasePlugin
        getASTPlugin(ASTNode self, string name) -> ASTBasePlugin


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getASTPlugin(SBMLNamespaces  sbmlns)

        ______________________________________________________________________
        Method variant with the following signature:

            getASTPlugin(string name, bool isCsymbol = false, bool
        strCmpIsCaseSensitive = false)

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            getASTPlugin(ASTNodeType_t type)

        """
        return _libsbml.ASTNode_getASTPlugin(self, *args)


    def getPlugin(self, *args):
        """
        getPlugin(ASTNode self, string package) -> ASTBasePlugin
        getPlugin(ASTNode self, string package) -> ASTBasePlugin
        getPlugin(ASTNode self, unsigned int n) -> ASTBasePlugin
        getPlugin(ASTNode self, unsigned int n) -> ASTBasePlugin
        """
        return _libsbml.ASTNode_getPlugin(self, *args)


    def getNumPlugins(self):
        """
        getNumPlugins(ASTNode self) -> unsigned int


        Internal implementation method.

        """
        return _libsbml.ASTNode_getNumPlugins(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


    def getListOfNodes(self):
        """
        getListOfNodes(ASTNode self) -> ASTNodeList


        Returns a list of nodes.

        Unlike the equivalent method in the libSBML C/C++ interface, this method does
        not offer the ability to pass a predicate as an argument.  The method always
        returns the list of all ASTNode objects.

        @return the ASTNodeList of nodes.

        @warning The list returned is owned by the caller and should be deleted after
        the caller is done using it.  The ASTNode objects in the list; however, are
        <strong>not</strong> owned by the caller (as they still belong to the tree
        itself), and therefore should not be deleted.

        """
        return _libsbml.ASTNode_getListOfNodes(self)

ASTNode_swigregister = _libsbml.ASTNode_swigregister
ASTNode_swigregister(ASTNode)


def readMathMLFromString(xml):
    """
    readMathMLFromString(char const * xml) -> ASTNode


    Reads the MathML from the given XML string, constructs a corresponding
    abstract syntax tree, and returns a pointer to the root of the tree.

    Parameter 'xml' is a string containing a full MathML expression

    Returns the root of an AST corresponding to the given mathematical
    expression, otherwise 'None' is returned if the given string is 'None'
    or invalid.

    """
    return _libsbml.readMathMLFromString(xml)

def readMathMLFromStringWithNamespaces(xml, xmlns):
    """
    readMathMLFromStringWithNamespaces(char const * xml, XMLNamespaces xmlns) -> ASTNode


    Reads the MathML from the given XML string, constructs a corresponding
    abstract syntax tree, and returns a pointer to the root of the tree.

    Parameter 'xml' is a string containing a full MathML expression
    Parameter 'xmlns' is an XMLNamespaces object containing namespaces
    that are considered active during the read. (For example, an SBML
    Level 3 package namespace.)

    Returns the root of an AST corresponding to the given mathematical
    expression, otherwise 'None' is returned if the given string is 'None'
    or invalid.

    """
    return _libsbml.readMathMLFromStringWithNamespaces(xml, xmlns)

def writeMathMLToString(node):
    """
    writeMathMLToString(ASTNode node) -> char *


    Writes the given ASTNode (and its children) to a string as MathML, and
    returns the string.

    Parameter 'node' is the root of an AST to write out to the stream.

    Returns a string containing the written-out MathML representation of
    the given AST.

    Note: The string is owned by the caller and should be freed (with
    free()) when no longer needed.  'None' is returned if the given
    argument is 'None.'

    """
    return _libsbml.writeMathMLToString(node)

def writeMathMLWithNamespaceToString(node, sbmlns):
    """
    writeMathMLWithNamespaceToString(ASTNode node, SBMLNamespaces sbmlns) -> char *


    Writes the given AST node (and its children) to a string as MathML,
    and returns the string.

    Parameter 'node' is the root of an AST to write out to the stream.
    Parameter 'sbmlns' is the SBML namespace to be used

    Returns a string containing the written-out MathML representation of
    the given AST.

    Note: The string is owned by the caller and should be freed (with
    free()) when no longer needed.  'None' is returned if the given
    argument is 'None.'

    """
    return _libsbml.writeMathMLWithNamespaceToString(node, sbmlns)

def parseFormula(formula):
    """
    parseFormula(char const * formula) -> ASTNode


    Parses the given SBML formula and returns a representation of it as an
    Abstract Syntax Tree (AST).

    The text-string form of mathematical formulas produced by
    formulaToString() and read by parseFormula() use a simple C-inspired
    infix notation taken from SBML Level 1.  A formula in this text-string
    form therefore can be handed to a program that understands SBML Level
    1 mathematical expressions, or used as part of a formula translation
    system. The syntax is described in detail in the documentation for
    ASTNode.  The following are illustrative examples of formulas
    expressed using this syntax:

      0.10 * k4^2

      (vm * s1)/(km + s1)

    Note that this facility is provided as a convenience by libSBML---the
    MathML standard does not actually define a 'string-form' equivalent to
    MathML expression trees, so the choice of formula syntax is somewhat
    arbitrary.  The approach taken by libSBML is to use the syntax defined
    by SBML Level 1 (which in fact used a text-string representation of
    formulas and not MathML).  This formula syntax is based mostly on C
    programming syntax, and may contain operators, function calls,
    symbols, and white space characters.  The following table provides the
    precedence rules for the different entities that may appear in formula
    strings.

      +--------------+---------------------+---------+------------+------------+
      | Token        | Operation           | Class   | Precedence | Associates |
      +--------------+---------------------+---------+------------+------------+
      | name         | symbol reference    | operand | 6          | n/a        |
      | (expression) | expression grouping | operand | 6          | n/a        |
      | f(...)       | function call       | prefix  | 6          | left       |
      | -            | negation            | unary   | 5          | right      |
      | ^            | power               | binary  | 4          | left       |
      | *            | multiplication      | binary  | 3          | left       |
      | /            | divison             | binary  | 3          | left       |
      | +            | addition            | binary  | 2          | left       |
      | -            | subtraction         | binary  | 2          | left       |
      | ,            | argument delimiter  | binary  | 1          | left       |
      +--------------+---------------------+---------+------------+------------+

    In the table above, operand implies the construct is an operand,
    prefix implies the operation is applied to the following arguments,
    unary implies there is one argument, and binary implies there are two
    arguments.  The values in the Precedence column show how the order of
    different types of operation are determined.  For example, the
    expression a * b + c is evaluated as (a * b) + c because the '*'
    operator has higher precedence.  The Associates column shows how the
    order of similar precedence operations is determined; for example, a -
    b + c is evaluated as (a - b) + c because the '+' and '-' operators
    are left-associative.

    The function call syntax consists of a function name, followed by
    optional white space, followed by an opening parenthesis token,
    followed by a sequence of zero or more arguments separated by commas
    (with each comma optionally preceded and/or followed by zero or more
    white space characters, followed by a closing parenthesis token.  The
    function name must be chosen from one of the pre-defined functions in
    SBML or a user-defined function in the model.  The following table
    lists the names of certain common mathematical functions; this table
    corresponds to Table 6 in the SBML Level 1 Version 2 specification:

      +-------+------+-------------------------------------------------------------------+--------------------------------+--------------------+
      | Name  | Args | Formula or meaning                                                | Argument Constraints           | Result constraints |
      +-------+------+-------------------------------------------------------------------+--------------------------------+--------------------+
      | abs   | x    | absolute value of x                                               |                                |                    |
      | acos  | x    | arc cosine of x in radians                                        | -1.0 <= x <= 1.0               | 0 <= acos(x) <= Pi |
      | asin  | x    | arc sine of x in radians                                          | -1.0 <= x <= 1.0               | 0 <= asin(x) <= Pi |
      | atan  | x    | arc tangent of x in radians                                       |                                | 0 <= atan(x) <= Pi |
      | ceil  | x    | smallest number not less than x whose value is an exact integer   |                                |                    |
      | cos   | x    | cosine of x                                                       |                                |                    |
      | exp   | x    | e^x, where e is the base of the natural logarithm                 |                                |                    |
      | floor | x    | largest number not greater than x whose value is an exact integer |                                |                    |
      | log   | x    | natural logarithm of x                                            | x > 0                          |                    |
      | log10 | x    | base 10 logarithm of x                                            | x > 0                          |                    |
      | pow   | x, y | x^y                                                               |                                |                    |
      | sqr   | x    | x^2                                                               |                                |                    |
      | sqrt  | x    | &radic;x                                                          | x > 0                          | sqrt(x) >= 0       |
      | sin   | x    | sine of x                                                         |                                |                    |
      | tan   | x    | tangent of x                                                      | x != n*Pi/2, for odd integer n |                    |
      +-------+------+-------------------------------------------------------------------+--------------------------------+--------------------+

    WARNING:

    There are differences between the symbols used to represent the common
    mathematical functions and the corresponding MathML token names.  This
    is a potential source of incompatibilities. Note in particular that in
    this text-string syntax, log(x) represents the natural logarithm,
    whereas in MathML, the natural logarithm is <ln/>.  Application
    writers are urged to be careful when translating between text forms
    and MathML forms, especially if they provide a direct text-string
    input facility to users of their software systems.

    @copydetails doc_warning_L1_math_string_syntax

    Parameter 'formula' is the text-string formula expression to be parsed

    Returns the root node of the AST corresponding to the 'formula', or
    'None' if an error occurred in parsing the formula

    See also libsbml.formulaToString(),
    libsbml.parseL3FormulaWithSettings(), libsbml.parseL3Formula(),
    libsbml.parseL3FormulaWithModel(), libsbml.getLastParseL3Error(),
    libsbml.getDefaultL3ParserSettings().

    """
    return _libsbml.parseFormula(formula)

def formulaToL3String(tree):
    """
    formulaToL3String(ASTNode tree) -> char *


    Converts an AST to a string representation of a formula using a syntax
    derived from SBML Level 1, but extended to include elements from SBML
    Level 2 and SBML Level 3.

    The text-string form of mathematical formulas read by the function
    parseL3Formula() and written by the function formulaToL3String() uses
    an expanded version of the syntax read and written by parseFormula()
    and formulaToString(), respectively.  The latter two libSBML functions
    were originally developed to support conversion between SBML Levels 1
    and 2, and were focused on the syntax of mathematical formulas used in
    SBML Level 1.  With time, and the use of MathML in SBML Levels 2 and
    3, it became clear that supporting Level 2 and 3's expanded
    mathematical syntax would be useful for software developers.  To
    maintain backwards compatibility for libSBML users, the original
    formulaToString() and parseFormula() have been left untouched, and
    instead, the new functionality is provided in the form of
    parseL3Formula() and formulaToL3String().

    The following lists the main differences in the formula syntax
    supported by the Level 3 ('L3') versions of the formula parsers and
    formatters, compared to what is supported by the Level 1-oriented
    parseFormula() and formulaToString():

    * Units may be asociated with bare numbers, using the following
    syntax:

    number unit

    The number may be in any form (an integer, real, or rational number),
    and the unit must conform to the syntax of an SBML identifier
    (technically, the type defined as 'SId' in the SBML specifications).
    The whitespace between number and unit is optional.

    * The Boolean function symbols '&&' (and), '||' (or), '!' (not),
    and '!=' (not equals) may be used.

    * The modulo operation is allowed as the symbol '%' and will
    produce a <piecewise> function in the corresponding MathML output by
    default, or can produce the MathML function 'rem,'  depending on the
    L3ParserSettings object (see  L3ParserSettings_setParseModuloL3v2() ).

    * All inverse trigonometric functions may be defined in the infix
    either using 'arc' as a prefix or simply 'a;' in other words, both
    'arccsc' and 'acsc' are interpreted as the operator arccosecant as
    defined in MathML 2.0.  (Many functions in the simpler SBML Level 1
    oriented parser implemented by parseFormula() are defined this way as
    well, but not all.)

    * The following expression is parsed as a rational number instead
    of as a numerical division:

      (integer/integer)

    Spaces are not allowed in this construct; in other words, "(3 / 4)"
    (with whitespace between the numbers and the operator) will be parsed
    into the MathML <divide> construct rather than a rational number.  You
    can, however, assign units to a rational number as a whole; here is an
    example: "(3/4) ml". (In the case of division rather than a rational
    number, units are not interpreted in this way.)

    * Various parser and formatter behaviors may be altered through
    the use of a L3ParserSettings object in conjunction with the functions
    parseL3FormulaWithSettings() and formulaToL3StringWithSettings() The
    settings available include the following:

    * The function 'log' with a single argument ("log(x)") can be parsed
    as log10(x), ln(x), or treated as an error, as desired.

    * Unary minus signs can be collapsed or preserved; that is, sequential
    pairs of unary minuses (e.g., "- -3") can be removed from the input
    entirely and single unary minuses can be incorporated into the number
    node, or all minuses can be preserved in the AST node structure.

    * Parsing of units embedded in the input string can be turned on and
    off.

    * The string 'avogadro' can be parsed as a MathML csymbol or as an
    identifier.

    * The string % can be parsed either as a  piecewise function or as the
    'rem' function:  a % b will either become

    piecewise(a - b*ceil(a/b), xor((a < 0), (b < 0)), a - b*floor(a/b))

    or

    rem(a, b).

    The latter is simpler, but the 'rem' MathML is only allowed as of SBML
    Level 3 Version 2.* A Model object may optionally be provided to the
    parser using the variant function call parseL3FormulaWithModel() or
    stored in a L3ParserSettings object passed to the variant function
    parseL3FormulaWithSettings().  When a Model object is provided,
    identifiers (values of type 'SId' ) from that model are used in
    preference to pre-defined MathML definitions for both symbols and
    functions. More precisely:

    * In the case of symbols: the Model entities whose identifiers will
    shadow identical symbols in the mathematical formula are: Species,
    Compartment, Parameter, Reaction, and SpeciesReference.  For instance,
    if the parser is given a Model containing a Species with the
    identifier "pi", and the formula to be parsed is "3*pi", the
    MathML produced will contain the construct <ci> pi </ci> instead of
    the construct <pi/>.

    * In the case of user-defined functions: when a Model object is
    provided, 'SId' values of user-defined functions present in the model
    will be used preferentially over pre-defined MathML functions.  For
    example, if the passed-in Model contains a FunctionDefinition object
    with the identifier "sin", that function will be used instead of the
    predefined MathML function <sin/>.

    * An SBMLNamespaces object may optionally be provided to identify
    SBML Level 3 packages that extend the syntax understood by the formula
    parser.  When the namespaces are provided, the parser will interpret
    possible additional syntax defined by the libSBML plug-ins
    implementing the SBML Level 3 packages; for example, it may understand
    vector/array extensions introduced by the SBML Level 3 Arrays package.
    These configuration settings cannot be changed directly using the
    basic parser and formatter functions, but can be changed on a per-call
    basis by using the alternative functions parseL3FormulaWithSettings()
    and formulaToL3StringWithSettings().

    Neither SBML nor the MathML standard define a 'string-form' equivalent
    to MathML expressions.  The approach taken by libSBML is to start with
    the formula syntax defined by SBML Level 1 (which in fact used a
    custom text-string representation of formulas, and not MathML), and
    expand it to include the functionality described above.  This formula
    syntax is based mostly on C programming syntax, and may contain
    operators, function calls, symbols, and white space characters.  The
    following table provides the precedence rules for the different
    entities that may appear in formula strings.

      +----------------------+--------------------------+---------+---------+--------+
      | Token                | Operation                | Class   | Preced. | Assoc. |
      +----------------------+--------------------------+---------+---------+--------+
      | name                 | symbol reference         | operand | 8       | n/a    |
      | (expression)         | expression grouping      | operand | 8       | n/a    |
      | f(...)               | function call            | prefix  | 8       | left   |
      | ^                    | power                    | binary  | 7       | left   |
      | -, !                 | negation, Boolean 'not'  | unary   | 6       | right  |
      | *, /, %              | multip., div., modulo    | binary  | 5       | left   |
      | +, -                 | addition and subtraction | binary  | 4       | left   |
      | ==, <, >, <=, >=, != | Boolean comparisons      | binary  | 3       | left   |
      | &&, ||               | Boolean 'and' and 'or'   | binary  | 2       | left   |
      | ,                    | argument delimiter       | binary  | 1       | left   |
      +----------------------+--------------------------+---------+---------+--------+

    In the table above, operand implies the construct is an operand,
    prefix implies the operation is applied to the following arguments,
    unary implies there is one argument, and binary implies there are two
    arguments.  The values in the Precedence column show how the order of
    different types of operation are determined.  For example, the
    expression a + b * c is evaluated as a + (b * c) because the '*'
    operator has higher precedence.  The Associates column shows how the
    order of similar precedence operations is determined; for example, a
    && b || c is evaluated as (a && b) || c because the '&&' and '||'
    operators are left-associative and have the same precedence.

    The function call syntax consists of a function name, followed by
    optional white space, followed by an opening parenthesis token,
    followed by a sequence of zero or more arguments separated by commas
    (with each comma optionally preceded and/or followed by zero or more
    white space characters), followed by a closing parenthesis token.  The
    function name must be chosen from one of the pre-defined functions in
    SBML or a user-defined function in the model.  The following table
    lists the names of certain common mathematical functions; this table
    corresponds to Table 6 in the SBML Level 1 Version 2 specification
    with additions based on the functions added in SBML Level 2 and Level
    3:

      +----------------+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------+--------------------+
      | Name           | Argument(s)                 | Formula or meaning                                                                                                                                                                    | Argument Constraints             | Result constraints |
      +----------------+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------+--------------------+
      | abs            | x                           | Absolute value of x.                                                                                                                                                                  |                                  |                    |
      | acos, arccos   | x                           | Arccosine of x in radians.                                                                                                                                                            | -1.0 <= x <= 1.0                 | 0 <= acos(x) <= Pi |
      | acosh, arccosh | x                           | Hyperbolic arccosine of x in radians.                                                                                                                                                 |                                  |                    |
      | acot, arccot   | x                           | Arccotangent of x in radians.                                                                                                                                                         |                                  |                    |
      | acoth, arccoth | x                           | Hyperbolic arccotangent of x in radians.                                                                                                                                              |                                  |                    |
      | acsc, arccsc   | x                           | Arccosecant of x in radians.                                                                                                                                                          |                                  |                    |
      | acsch, arccsch | x                           | Hyperbolic arccosecant of x in radians.                                                                                                                                               |                                  |                    |
      | asec, arcsec   | x                           | Arcsecant of x in radians.                                                                                                                                                            |                                  |                    |
      | asech, arcsech | x                           | Hyperbolic arcsecant of x in radians.                                                                                                                                                 |                                  |                    |
      | asin, arcsin   | x                           | Arcsine of x in radians.                                                                                                                                                              | -1.0 <= x <= 1.0                 | 0 <= asin(x) <= Pi |
      | atan, arctan   | x                           | Arctangent of x in radians.                                                                                                                                                           |                                  | 0 <= atan(x) <= Pi |
      | atanh, arctanh | x                           | Hyperbolic arctangent of x in radians.                                                                                                                                                |                                  |                    |
      | ceil, ceiling  | x                           | Smallest number not less than x whose value is an exact integer.                                                                                                                      |                                  |                    |
      | cos            | x                           | Cosine of x                                                                                                                                                                           |                                  |                    |
      | cosh           | x                           | Hyperbolic cosine of x.                                                                                                                                                               |                                  |                    |
      | cot            | x                           | Cotangent of x.                                                                                                                                                                       |                                  |                    |
      | coth           | x                           | Hyperbolic cotangent of x.                                                                                                                                                            |                                  |                    |
      | csc            | x                           | Cosecant of x.                                                                                                                                                                        |                                  |                    |
      | csch           | x                           | Hyperbolic cosecant of x.                                                                                                                                                             |                                  |                    |
      | delay          | x, y                        | The value of x at y time units in the past.                                                                                                                                           |                                  |                    |
      | factorial      | n                           | The factorial of n. Factorials are defined by n! = n*(n-1)* ... * 1.                                                                                                                  | n must be an integer.            |                    |
      | exp            | x                           | e^x, where e is the base of the natural logarithm.                                                                                                                                    |                                  |                    |
      | floor          | x                           | The largest number not greater than x whose value is an exact integer.                                                                                                                |                                  |                    |
      | ln             | x                           | Natural logarithm of x.                                                                                                                                                               | x > 0                            |                    |
      | log            | x                           | By default, the base 10 logarithm of x, but can be set to be the natural logarithm of x, or to be an illegal construct.                                                               | x > 0                            |                    |
      | log            | x, y                        | The base x logarithm of y.                                                                                                                                                            | y > 0                            |                    |
      | log10          | x                           | Base 10 logarithm of x.                                                                                                                                                               | x > 0                            |                    |
      | piecewise      | x1, y1, [x2, y2,] [...] [z] | A piecewise function: if (y1), x1.  Otherwise, if (y2), x2, etc.  Otherwise, z.                                                                                                       | y1, y2, y3 [etc] must be Boolean |                    |
      | pow, power     | x, y                        | x^y.                                                                                                                                                                                  |                                  |                    |
      | root           | b, x                        | The root base b of x.                                                                                                                                                                 |                                  |                    |
      | sec            | x                           | Secant of x.                                                                                                                                                                          |                                  |                    |
      | sech           | x                           | Hyperbolic secant of x.                                                                                                                                                               |                                  |                    |
      | sqr            | x                           | x^2.                                                                                                                                                                                  |                                  |                    |
      | sqrt           | x                           | &radic;x.                                                                                                                                                                             | x > 0                            | sqrt(x) >= 0       |
      | sin            | x                           | Sine of x.                                                                                                                                                                            |                                  |                    |
      | sinh           | x                           | Hyperbolic sine of x.                                                                                                                                                                 |                                  |                    |
      | tan            | x                           | Tangent of x.                                                                                                                                                                         | x != n*Pi/2, for odd integer n   |                    |
      | tanh           | x                           | Hyperbolic tangent of x.                                                                                                                                                              |                                  |                    |
      | and            | x, y, z...                  | Boolean and(x, y, z...): returns true if all of its arguments are true.  Note that and is an n-ary function, taking 0 or more arguments, and that and() returns true.                 | All arguments must be Boolean    |                    |
      | not            | x                           | Boolean not(x)                                                                                                                                                                        | x must be Boolean                |                    |
      | or             | x, y, z...                  | Boolean or(x, y, z...): returns true if at least one of its arguments is true.  Note that or is an n-ary function, taking 0 or more arguments, and that or() returns false.           | All arguments must be Boolean    |                    |
      | xor            | x, y, z...                  | Boolean xor(x, y, z...): returns true if an odd number of its arguments is true.  Note that xor is an n-ary function, taking 0 or more arguments, and that xor() returns false.       | All arguments must be Boolean    |                    |
      | eq             | x, y, z...                  | Boolean eq(x, y, z...): returns true if all arguments are equal.  Note that eq is an n-ary function, but must take 2 or more arguments.                                               |                                  |                    |
      | geq            | x, y, z...                  | Boolean geq(x, y, z...): returns true if each argument is greater than or equal to the argument following it.  Note that geq is an n-ary function, but must take 2 or more arguments. |                                  |                    |
      | gt             | x, y, z...                  | Boolean gt(x, y, z...): returns true if each argument is greater than the argument following it.  Note that gt is an n-ary function, but must take 2 or more arguments.               |                                  |                    |
      | leq            | x, y, z...                  | Boolean leq(x, y, z...): returns true if each argument is less than or equal to the argument following it.  Note that leq is an n-ary function, but must take 2 or more arguments.    |                                  |                    |
      | lt             | x, y, z...                  | Boolean lt(x, y, z...): returns true if each argument is less than the argument following it.  Note that lt is an n-ary function, but must take 2 or more arguments.                  |                                  |                    |
      | neq            | x, y                        | Boolean x != y: returns true unless x and y are equal.                                                                                                                                |                                  |                    |
      | plus           | x, y, z...                  | x + y + z + ...: The sum of the arguments of the function.  Note that plus is an n-ary function taking 0 or more arguments, and that plus() returns 0.                                |                                  |                    |
      | times          | x, y, z...                  | x * y * z * ...: The product of the arguments of the function.  Note that times is an n-ary function taking 0 or more arguments, and that times() returns 1.                          |                                  |                    |
      | minus          | x, y                        | x - y.                                                                                                                                                                                |                                  |                    |
      | divide         | x, y                        | x / y.                                                                                                                                                                                |                                  |                    |
      +----------------+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------+--------------------+

    Parsing of the various MathML functions and constants are all case-
    insensitive by default: function names such as cos, Cos and COS are
    all parsed as the MathML cosine operator, <cos>.  However, when a
    Model object is used in conjunction with either
    parseL3FormulaWithModel() or parseL3FormulaWithSettings(), any
    identifiers found in that model will be parsed in a case-sensitive
    way.  For example, if a model contains a Species having the identifier
    Pi, the parser will parse "Pi" in the input as "<ci> Pi </ci>" but
    will continue to parse the symbols "pi" and "PI" as "<pi>".

    As mentioned above, the manner in which the 'L3' versions of the
    formula parser and formatter interpret the function "log" can be
    changed.  To do so, callers should use the function
    parseL3FormulaWithSettings() and pass it an appropriate
    L3ParserSettings object.  By default, unlike the SBML Level 1 parser
    implemented by parseFormula(), the string "log" is interpreted as
    the base 10 logarithm, and not as the natural logarithm.  However, you
    can change the interpretation to be base-10 log, natural log, or as an
    error; since the name 'log' by itself is ambiguous, you require that
    the parser uses 'log10' or 'ln' instead, which are more clear.  Please
    refer to parseL3FormulaWithSettings().

    In addition, the following symbols will be translated to their MathML
    equivalents, if no symbol with the same 'SId' identifier string exists
    in the Model object provided:

      +-----------------+-------------------------------------------------+--------------------------------------------------------------------------------------------------------------+
      | Name            | Meaning                                         | MathML                                                                                                       |
      +-----------------+-------------------------------------------------+--------------------------------------------------------------------------------------------------------------+
      | true            | Boolean value true                              | <true/>                                                                                                      |
      | false           | Boolean value false                             | <false/>                                                                                                     |
      | pi              | Mathematical constant pi                        | <pi/>                                                                                                        |
      | avogadro        | Value of Avogadro's constant stipulated by SBML | <csymbol encoding="text" definitionURL="http://www.sbml.org/sbml/symbols/avogadro"> avogadro </csymbol/> |
      | time            | Simulation time as defined in SBML              | <csymbol encoding="text" definitionURL="http://www.sbml.org/sbml/symbols/time"> time </csymbol/>         |
      | inf, infinity   | Mathematical constant "infinity"              | <infinity/>                                                                                                  |
      | nan, notanumber | Mathematical concept "not a number"           | <notanumber/>                                                                                                |
      +-----------------+-------------------------------------------------+--------------------------------------------------------------------------------------------------------------+

    Again, as mentioned above, whether the string "avogadro" is parsed
    as an AST node of type AST_NAME_AVOGADRO or AST_NAME is configurable;
    use the version of the parser function called
    parseL3FormulaWithSettings().  This Avogadro-related functionality is
    provided because SBML Level 2 models may not use AST_NAME_AVOGADRO AST
    nodes.

    Parameter 'tree' is the AST to be converted.

    Returns the formula from the given AST as an SBML Level 3 text-string
    mathematical formula.  The caller owns the returned string and is
    responsible for freeing it when it is no longer needed.

    See also libsbml.formulaToString(),
    libsbml.parseL3FormulaWithSettings(), libsbml.parseL3Formula(),
    libsbml.parseL3FormulaWithModel(), libsbml.getLastParseL3Error(),
    libsbml.getDefaultL3ParserSettings().

    """
    return _libsbml.formulaToL3String(tree)

def formulaToL3StringWithSettings(tree, settings):
    """
    formulaToL3StringWithSettings(ASTNode tree, L3ParserSettings settings) -> char *


    Converts an AST to a string representation of a formula using a syntax
    basically derived from SBML Level 1, with behavior modifiable with
    custom settings.

    This function behaves identically to SBML_formulaToL3String(), but
    its behavior can be modified by two settings in the Parameter
    'settings' is object, namely:

    * ParseUnits:  If this is set to 'true' (the default), the
    function will  write out the units of any numerical ASTNodes that have
    them, producing (for example) '3 mL', '(3/4) m', or '5.5e-10 M'.  If
    this is set to 'false', this function will only write out the number
    itself ('3', '(3/4)', and '5.5e-10', in the previous examples).

    * CollapseMinus: If this is set to 'false' (the default), the
    function will write out explicitly any doubly-nested unary minus
    ASTNodes, producing (for example) '--x' or even '-----3.1'.  If this
    is set to 'true', the function will collapse the nodes before
    producing the infix, producing 'x' and '-3.1' in the previous
    examples.

    All other settings will not affect the behavior of this function:  the
    'parseLog' setting is ignored, and 'log10(x)', 'ln(x)', and 'log(x,
    y)'  are always produced.  Nothing in the Model object is used, and
    whether Avogadro is a csymbol or not is immaterial to the produced
    infix.

    Parameter 'tree' is the AST to be converted. Parameter 'settings' is
    the L3ParserSettings object used to modify behavior.

    Returns the formula from the given AST as an SBML Level 3 text-string
    mathematical formula.  The caller owns the returned string and is
    responsible for freeing it when it is no longer needed.

    See also SBML_parseFormula(), SBML_parseL3Formula(),
    SBML_formulaToL3String().

    """
    return _libsbml.formulaToL3StringWithSettings(tree, settings)

def formulaToString(tree):
    """
    formulaToString(ASTNode tree) -> char *


    Converts an AST to a string representation of a formula using a syntax
    basically derived from SBML Level 1.

    The text-string form of mathematical formulas produced by
    formulaToString() and read by parseFormula() use a simple C-inspired
    infix notation taken from SBML Level 1.  A formula in this text-string
    form therefore can be handed to a program that understands SBML Level
    1 mathematical expressions, or used as part of a formula translation
    system. The syntax is described in detail in the documentation for
    ASTNode.  The following are illustrative examples of formulas
    expressed using this syntax:

      0.10 * k4^2

      (vm * s1)/(km + s1)

    Note that this facility is provided as a convenience by libSBML---the
    MathML standard does not actually define a 'string-form' equivalent to
    MathML expression trees, so the choice of formula syntax is somewhat
    arbitrary.  The approach taken by libSBML is to use the syntax defined
    by SBML Level 1 (which in fact used a text-string representation of
    formulas and not MathML).  This formula syntax is based mostly on C
    programming syntax, and may contain operators, function calls,
    symbols, and white space characters.  The following table provides the
    precedence rules for the different entities that may appear in formula
    strings.

      +--------------+---------------------+---------+------------+------------+
      | Token        | Operation           | Class   | Precedence | Associates |
      +--------------+---------------------+---------+------------+------------+
      | name         | symbol reference    | operand | 6          | n/a        |
      | (expression) | expression grouping | operand | 6          | n/a        |
      | f(...)       | function call       | prefix  | 6          | left       |
      | -            | negation            | unary   | 5          | right      |
      | ^            | power               | binary  | 4          | left       |
      | *            | multiplication      | binary  | 3          | left       |
      | /            | divison             | binary  | 3          | left       |
      | +            | addition            | binary  | 2          | left       |
      | -            | subtraction         | binary  | 2          | left       |
      | ,            | argument delimiter  | binary  | 1          | left       |
      +--------------+---------------------+---------+------------+------------+

    In the table above, operand implies the construct is an operand,
    prefix implies the operation is applied to the following arguments,
    unary implies there is one argument, and binary implies there are two
    arguments.  The values in the Precedence column show how the order of
    different types of operation are determined.  For example, the
    expression a * b + c is evaluated as (a * b) + c because the '*'
    operator has higher precedence.  The Associates column shows how the
    order of similar precedence operations is determined; for example, a -
    b + c is evaluated as (a - b) + c because the '+' and '-' operators
    are left-associative.

    The function call syntax consists of a function name, followed by
    optional white space, followed by an opening parenthesis token,
    followed by a sequence of zero or more arguments separated by commas
    (with each comma optionally preceded and/or followed by zero or more
    white space characters, followed by a closing parenthesis token.  The
    function name must be chosen from one of the pre-defined functions in
    SBML or a user-defined function in the model.  The following table
    lists the names of certain common mathematical functions; this table
    corresponds to Table 6 in the SBML Level 1 Version 2 specification:

      +-------+------+-------------------------------------------------------------------+--------------------------------+--------------------+
      | Name  | Args | Formula or meaning                                                | Argument Constraints           | Result constraints |
      +-------+------+-------------------------------------------------------------------+--------------------------------+--------------------+
      | abs   | x    | absolute value of x                                               |                                |                    |
      | acos  | x    | arc cosine of x in radians                                        | -1.0 <= x <= 1.0               | 0 <= acos(x) <= Pi |
      | asin  | x    | arc sine of x in radians                                          | -1.0 <= x <= 1.0               | 0 <= asin(x) <= Pi |
      | atan  | x    | arc tangent of x in radians                                       |                                | 0 <= atan(x) <= Pi |
      | ceil  | x    | smallest number not less than x whose value is an exact integer   |                                |                    |
      | cos   | x    | cosine of x                                                       |                                |                    |
      | exp   | x    | e^x, where e is the base of the natural logarithm                 |                                |                    |
      | floor | x    | largest number not greater than x whose value is an exact integer |                                |                    |
      | log   | x    | natural logarithm of x                                            | x > 0                          |                    |
      | log10 | x    | base 10 logarithm of x                                            | x > 0                          |                    |
      | pow   | x, y | x^y                                                               |                                |                    |
      | sqr   | x    | x^2                                                               |                                |                    |
      | sqrt  | x    | &radic;x                                                          | x > 0                          | sqrt(x) >= 0       |
      | sin   | x    | sine of x                                                         |                                |                    |
      | tan   | x    | tangent of x                                                      | x != n*Pi/2, for odd integer n |                    |
      +-------+------+-------------------------------------------------------------------+--------------------------------+--------------------+

    WARNING:

    There are differences between the symbols used to represent the common
    mathematical functions and the corresponding MathML token names.  This
    is a potential source of incompatibilities. Note in particular that in
    this text-string syntax, log(x) represents the natural logarithm,
    whereas in MathML, the natural logarithm is <ln/>.  Application
    writers are urged to be careful when translating between text forms
    and MathML forms, especially if they provide a direct text-string
    input facility to users of their software systems.

    @copydetails doc_warning_L1_math_string_syntax

    Parameter 'tree' is the AST to be converted.

    Returns the formula from the given AST as an SBML Level 1 text-string
    mathematical formula.  The caller owns the returned string and is
    responsible for freeing it when it is no longer needed.

    See also libsbml.formulaToString(),
    libsbml.parseL3FormulaWithSettings(), libsbml.parseL3Formula(),
    libsbml.parseL3FormulaWithModel(), libsbml.getLastParseL3Error(),
    libsbml.getDefaultL3ParserSettings().

    """
    return _libsbml.formulaToString(tree)

def parseL3Formula(formula):
    """
    parseL3Formula(char const * formula) -> ASTNode


    Parses a text string as a mathematical formula and returns an AST
    representation of it.

    The text-string form of mathematical formulas read by the function
    parseL3Formula() and written by the function formulaToL3String() uses
    an expanded version of the syntax read and written by parseFormula()
    and formulaToString(), respectively.  The latter two libSBML functions
    were originally developed to support conversion between SBML Levels 1
    and 2, and were focused on the syntax of mathematical formulas used in
    SBML Level 1.  With time, and the use of MathML in SBML Levels 2 and
    3, it became clear that supporting Level 2 and 3's expanded
    mathematical syntax would be useful for software developers.  To
    maintain backwards compatibility for libSBML users, the original
    formulaToString() and parseFormula() have been left untouched, and
    instead, the new functionality is provided in the form of
    parseL3Formula() and formulaToL3String().

    The following lists the main differences in the formula syntax
    supported by the Level 3 ('L3') versions of the formula parsers and
    formatters, compared to what is supported by the Level 1-oriented
    parseFormula() and formulaToString():

    * Units may be asociated with bare numbers, using the following
    syntax:

    number unit

    The number may be in any form (an integer, real, or rational number),
    and the unit must conform to the syntax of an SBML identifier
    (technically, the type defined as 'SId' in the SBML specifications).
    The whitespace between number and unit is optional.

    * The Boolean function symbols '&&' (and), '||' (or), '!' (not),
    and '!=' (not equals) may be used.

    * The modulo operation is allowed as the symbol '%' and will
    produce a <piecewise> function in the corresponding MathML output by
    default, or can produce the MathML function 'rem,'  depending on the
    L3ParserSettings object (see  L3ParserSettings_setParseModuloL3v2() ).

    * All inverse trigonometric functions may be defined in the infix
    either using 'arc' as a prefix or simply 'a;' in other words, both
    'arccsc' and 'acsc' are interpreted as the operator arccosecant as
    defined in MathML 2.0.  (Many functions in the simpler SBML Level 1
    oriented parser implemented by parseFormula() are defined this way as
    well, but not all.)

    * The following expression is parsed as a rational number instead
    of as a numerical division:

      (integer/integer)

    Spaces are not allowed in this construct; in other words, "(3 / 4)"
    (with whitespace between the numbers and the operator) will be parsed
    into the MathML <divide> construct rather than a rational number.  You
    can, however, assign units to a rational number as a whole; here is an
    example: "(3/4) ml". (In the case of division rather than a rational
    number, units are not interpreted in this way.)

    * Various parser and formatter behaviors may be altered through
    the use of a L3ParserSettings object in conjunction with the functions
    parseL3FormulaWithSettings() and formulaToL3StringWithSettings() The
    settings available include the following:

    * The function 'log' with a single argument ("log(x)") can be parsed
    as log10(x), ln(x), or treated as an error, as desired.

    * Unary minus signs can be collapsed or preserved; that is, sequential
    pairs of unary minuses (e.g., "- -3") can be removed from the input
    entirely and single unary minuses can be incorporated into the number
    node, or all minuses can be preserved in the AST node structure.

    * Parsing of units embedded in the input string can be turned on and
    off.

    * The string 'avogadro' can be parsed as a MathML csymbol or as an
    identifier.

    * The string % can be parsed either as a  piecewise function or as the
    'rem' function:  a % b will either become

    piecewise(a - b*ceil(a/b), xor((a < 0), (b < 0)), a - b*floor(a/b))

    or

    rem(a, b).

    The latter is simpler, but the 'rem' MathML is only allowed as of SBML
    Level 3 Version 2.* A Model object may optionally be provided to the
    parser using the variant function call parseL3FormulaWithModel() or
    stored in a L3ParserSettings object passed to the variant function
    parseL3FormulaWithSettings().  When a Model object is provided,
    identifiers (values of type 'SId' ) from that model are used in
    preference to pre-defined MathML definitions for both symbols and
    functions. More precisely:

    * In the case of symbols: the Model entities whose identifiers will
    shadow identical symbols in the mathematical formula are: Species,
    Compartment, Parameter, Reaction, and SpeciesReference.  For instance,
    if the parser is given a Model containing a Species with the
    identifier "pi", and the formula to be parsed is "3*pi", the
    MathML produced will contain the construct <ci> pi </ci> instead of
    the construct <pi/>.

    * In the case of user-defined functions: when a Model object is
    provided, 'SId' values of user-defined functions present in the model
    will be used preferentially over pre-defined MathML functions.  For
    example, if the passed-in Model contains a FunctionDefinition object
    with the identifier "sin", that function will be used instead of the
    predefined MathML function <sin/>.

    * An SBMLNamespaces object may optionally be provided to identify
    SBML Level 3 packages that extend the syntax understood by the formula
    parser.  When the namespaces are provided, the parser will interpret
    possible additional syntax defined by the libSBML plug-ins
    implementing the SBML Level 3 packages; for example, it may understand
    vector/array extensions introduced by the SBML Level 3 Arrays package.
    These configuration settings cannot be changed directly using the
    basic parser and formatter functions, but can be changed on a per-call
    basis by using the alternative functions parseL3FormulaWithSettings()
    and formulaToL3StringWithSettings().

    Neither SBML nor the MathML standard define a 'string-form' equivalent
    to MathML expressions.  The approach taken by libSBML is to start with
    the formula syntax defined by SBML Level 1 (which in fact used a
    custom text-string representation of formulas, and not MathML), and
    expand it to include the functionality described above.  This formula
    syntax is based mostly on C programming syntax, and may contain
    operators, function calls, symbols, and white space characters.  The
    following table provides the precedence rules for the different
    entities that may appear in formula strings.

      +----------------------+--------------------------+---------+---------+--------+
      | Token                | Operation                | Class   | Preced. | Assoc. |
      +----------------------+--------------------------+---------+---------+--------+
      | name                 | symbol reference         | operand | 8       | n/a    |
      | (expression)         | expression grouping      | operand | 8       | n/a    |
      | f(...)               | function call            | prefix  | 8       | left   |
      | ^                    | power                    | binary  | 7       | left   |
      | -, !                 | negation, Boolean 'not'  | unary   | 6       | right  |
      | *, /, %              | multip., div., modulo    | binary  | 5       | left   |
      | +, -                 | addition and subtraction | binary  | 4       | left   |
      | ==, <, >, <=, >=, != | Boolean comparisons      | binary  | 3       | left   |
      | &&, ||               | Boolean 'and' and 'or'   | binary  | 2       | left   |
      | ,                    | argument delimiter       | binary  | 1       | left   |
      +----------------------+--------------------------+---------+---------+--------+

    In the table above, operand implies the construct is an operand,
    prefix implies the operation is applied to the following arguments,
    unary implies there is one argument, and binary implies there are two
    arguments.  The values in the Precedence column show how the order of
    different types of operation are determined.  For example, the
    expression a + b * c is evaluated as a + (b * c) because the '*'
    operator has higher precedence.  The Associates column shows how the
    order of similar precedence operations is determined; for example, a
    && b || c is evaluated as (a && b) || c because the '&&' and '||'
    operators are left-associative and have the same precedence.

    The function call syntax consists of a function name, followed by
    optional white space, followed by an opening parenthesis token,
    followed by a sequence of zero or more arguments separated by commas
    (with each comma optionally preceded and/or followed by zero or more
    white space characters), followed by a closing parenthesis token.  The
    function name must be chosen from one of the pre-defined functions in
    SBML or a user-defined function in the model.  The following table
    lists the names of certain common mathematical functions; this table
    corresponds to Table 6 in the SBML Level 1 Version 2 specification
    with additions based on the functions added in SBML Level 2 and Level
    3:

      +----------------+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------+--------------------+
      | Name           | Argument(s)                 | Formula or meaning                                                                                                                                                                    | Argument Constraints             | Result constraints |
      +----------------+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------+--------------------+
      | abs            | x                           | Absolute value of x.                                                                                                                                                                  |                                  |                    |
      | acos, arccos   | x                           | Arccosine of x in radians.                                                                                                                                                            | -1.0 <= x <= 1.0                 | 0 <= acos(x) <= Pi |
      | acosh, arccosh | x                           | Hyperbolic arccosine of x in radians.                                                                                                                                                 |                                  |                    |
      | acot, arccot   | x                           | Arccotangent of x in radians.                                                                                                                                                         |                                  |                    |
      | acoth, arccoth | x                           | Hyperbolic arccotangent of x in radians.                                                                                                                                              |                                  |                    |
      | acsc, arccsc   | x                           | Arccosecant of x in radians.                                                                                                                                                          |                                  |                    |
      | acsch, arccsch | x                           | Hyperbolic arccosecant of x in radians.                                                                                                                                               |                                  |                    |
      | asec, arcsec   | x                           | Arcsecant of x in radians.                                                                                                                                                            |                                  |                    |
      | asech, arcsech | x                           | Hyperbolic arcsecant of x in radians.                                                                                                                                                 |                                  |                    |
      | asin, arcsin   | x                           | Arcsine of x in radians.                                                                                                                                                              | -1.0 <= x <= 1.0                 | 0 <= asin(x) <= Pi |
      | atan, arctan   | x                           | Arctangent of x in radians.                                                                                                                                                           |                                  | 0 <= atan(x) <= Pi |
      | atanh, arctanh | x                           | Hyperbolic arctangent of x in radians.                                                                                                                                                |                                  |                    |
      | ceil, ceiling  | x                           | Smallest number not less than x whose value is an exact integer.                                                                                                                      |                                  |                    |
      | cos            | x                           | Cosine of x                                                                                                                                                                           |                                  |                    |
      | cosh           | x                           | Hyperbolic cosine of x.                                                                                                                                                               |                                  |                    |
      | cot            | x                           | Cotangent of x.                                                                                                                                                                       |                                  |                    |
      | coth           | x                           | Hyperbolic cotangent of x.                                                                                                                                                            |                                  |                    |
      | csc            | x                           | Cosecant of x.                                                                                                                                                                        |                                  |                    |
      | csch           | x                           | Hyperbolic cosecant of x.                                                                                                                                                             |                                  |                    |
      | delay          | x, y                        | The value of x at y time units in the past.                                                                                                                                           |                                  |                    |
      | factorial      | n                           | The factorial of n. Factorials are defined by n! = n*(n-1)* ... * 1.                                                                                                                  | n must be an integer.            |                    |
      | exp            | x                           | e^x, where e is the base of the natural logarithm.                                                                                                                                    |                                  |                    |
      | floor          | x                           | The largest number not greater than x whose value is an exact integer.                                                                                                                |                                  |                    |
      | ln             | x                           | Natural logarithm of x.                                                                                                                                                               | x > 0                            |                    |
      | log            | x                           | By default, the base 10 logarithm of x, but can be set to be the natural logarithm of x, or to be an illegal construct.                                                               | x > 0                            |                    |
      | log            | x, y                        | The base x logarithm of y.                                                                                                                                                            | y > 0                            |                    |
      | log10          | x                           | Base 10 logarithm of x.                                                                                                                                                               | x > 0                            |                    |
      | piecewise      | x1, y1, [x2, y2,] [...] [z] | A piecewise function: if (y1), x1.  Otherwise, if (y2), x2, etc.  Otherwise, z.                                                                                                       | y1, y2, y3 [etc] must be Boolean |                    |
      | pow, power     | x, y                        | x^y.                                                                                                                                                                                  |                                  |                    |
      | root           | b, x                        | The root base b of x.                                                                                                                                                                 |                                  |                    |
      | sec            | x                           | Secant of x.                                                                                                                                                                          |                                  |                    |
      | sech           | x                           | Hyperbolic secant of x.                                                                                                                                                               |                                  |                    |
      | sqr            | x                           | x^2.                                                                                                                                                                                  |                                  |                    |
      | sqrt           | x                           | &radic;x.                                                                                                                                                                             | x > 0                            | sqrt(x) >= 0       |
      | sin            | x                           | Sine of x.                                                                                                                                                                            |                                  |                    |
      | sinh           | x                           | Hyperbolic sine of x.                                                                                                                                                                 |                                  |                    |
      | tan            | x                           | Tangent of x.                                                                                                                                                                         | x != n*Pi/2, for odd integer n   |                    |
      | tanh           | x                           | Hyperbolic tangent of x.                                                                                                                                                              |                                  |                    |
      | and            | x, y, z...                  | Boolean and(x, y, z...): returns true if all of its arguments are true.  Note that and is an n-ary function, taking 0 or more arguments, and that and() returns true.                 | All arguments must be Boolean    |                    |
      | not            | x                           | Boolean not(x)                                                                                                                                                                        | x must be Boolean                |                    |
      | or             | x, y, z...                  | Boolean or(x, y, z...): returns true if at least one of its arguments is true.  Note that or is an n-ary function, taking 0 or more arguments, and that or() returns false.           | All arguments must be Boolean    |                    |
      | xor            | x, y, z...                  | Boolean xor(x, y, z...): returns true if an odd number of its arguments is true.  Note that xor is an n-ary function, taking 0 or more arguments, and that xor() returns false.       | All arguments must be Boolean    |                    |
      | eq             | x, y, z...                  | Boolean eq(x, y, z...): returns true if all arguments are equal.  Note that eq is an n-ary function, but must take 2 or more arguments.                                               |                                  |                    |
      | geq            | x, y, z...                  | Boolean geq(x, y, z...): returns true if each argument is greater than or equal to the argument following it.  Note that geq is an n-ary function, but must take 2 or more arguments. |                                  |                    |
      | gt             | x, y, z...                  | Boolean gt(x, y, z...): returns true if each argument is greater than the argument following it.  Note that gt is an n-ary function, but must take 2 or more arguments.               |                                  |                    |
      | leq            | x, y, z...                  | Boolean leq(x, y, z...): returns true if each argument is less than or equal to the argument following it.  Note that leq is an n-ary function, but must take 2 or more arguments.    |                                  |                    |
      | lt             | x, y, z...                  | Boolean lt(x, y, z...): returns true if each argument is less than the argument following it.  Note that lt is an n-ary function, but must take 2 or more arguments.                  |                                  |                    |
      | neq            | x, y                        | Boolean x != y: returns true unless x and y are equal.                                                                                                                                |                                  |                    |
      | plus           | x, y, z...                  | x + y + z + ...: The sum of the arguments of the function.  Note that plus is an n-ary function taking 0 or more arguments, and that plus() returns 0.                                |                                  |                    |
      | times          | x, y, z...                  | x * y * z * ...: The product of the arguments of the function.  Note that times is an n-ary function taking 0 or more arguments, and that times() returns 1.                          |                                  |                    |
      | minus          | x, y                        | x - y.                                                                                                                                                                                |                                  |                    |
      | divide         | x, y                        | x / y.                                                                                                                                                                                |                                  |                    |
      +----------------+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------+--------------------+

    Parsing of the various MathML functions and constants are all case-
    insensitive by default: function names such as cos, Cos and COS are
    all parsed as the MathML cosine operator, <cos>.  However, when a
    Model object is used in conjunction with either
    parseL3FormulaWithModel() or parseL3FormulaWithSettings(), any
    identifiers found in that model will be parsed in a case-sensitive
    way.  For example, if a model contains a Species having the identifier
    Pi, the parser will parse "Pi" in the input as "<ci> Pi </ci>" but
    will continue to parse the symbols "pi" and "PI" as "<pi>".

    As mentioned above, the manner in which the 'L3' versions of the
    formula parser and formatter interpret the function "log" can be
    changed.  To do so, callers should use the function
    parseL3FormulaWithSettings() and pass it an appropriate
    L3ParserSettings object.  By default, unlike the SBML Level 1 parser
    implemented by parseFormula(), the string "log" is interpreted as
    the base 10 logarithm, and not as the natural logarithm.  However, you
    can change the interpretation to be base-10 log, natural log, or as an
    error; since the name 'log' by itself is ambiguous, you require that
    the parser uses 'log10' or 'ln' instead, which are more clear.  Please
    refer to parseL3FormulaWithSettings().

    In addition, the following symbols will be translated to their MathML
    equivalents, if no symbol with the same 'SId' identifier string exists
    in the Model object provided:

      +-----------------+-------------------------------------------------+--------------------------------------------------------------------------------------------------------------+
      | Name            | Meaning                                         | MathML                                                                                                       |
      +-----------------+-------------------------------------------------+--------------------------------------------------------------------------------------------------------------+
      | true            | Boolean value true                              | <true/>                                                                                                      |
      | false           | Boolean value false                             | <false/>                                                                                                     |
      | pi              | Mathematical constant pi                        | <pi/>                                                                                                        |
      | avogadro        | Value of Avogadro's constant stipulated by SBML | <csymbol encoding="text" definitionURL="http://www.sbml.org/sbml/symbols/avogadro"> avogadro </csymbol/> |
      | time            | Simulation time as defined in SBML              | <csymbol encoding="text" definitionURL="http://www.sbml.org/sbml/symbols/time"> time </csymbol/>         |
      | inf, infinity   | Mathematical constant "infinity"              | <infinity/>                                                                                                  |
      | nan, notanumber | Mathematical concept "not a number"           | <notanumber/>                                                                                                |
      +-----------------+-------------------------------------------------+--------------------------------------------------------------------------------------------------------------+

    Again, as mentioned above, whether the string "avogadro" is parsed
    as an AST node of type AST_NAME_AVOGADRO or AST_NAME is configurable;
    use the version of the parser function called
    parseL3FormulaWithSettings().  This Avogadro-related functionality is
    provided because SBML Level 2 models may not use AST_NAME_AVOGADRO AST
    nodes.

    Parameter 'formula' is the text-string formula expression to be
    parsed.

    Returns the root node of an AST representing the mathematical formula,
    or 'None' if an error occurred while parsing the formula.  When 'None'
    is returned, an error is recorded internally; information about the
    error can be retrieved using getLastParseL3Error().

    See also parseL3FormulaWithSettings(), parseL3FormulaWithModel(),
    parseFormula(), formulaToL3StringWithSettings(), formulaToL3String(),
    formulaToString(), L3ParserSettings, getDefaultL3ParserSettings(),
    getLastParseL3Error().

    Note: We urge developers to keep in mind that the text-string formula
    syntax is specific to libSBML.  Neither MathML nor SBML define a text-
    string format for mathematical formulas. LibSBML's particular syntax
    should not be considered to be a canonical or standard general-purpose
    mathematical expression syntax.  LibSBML provides methods for parsing
    and transforming text-string math formulas back and forth from AST
    structures for the convenience of calling applications, but it is
    important to keep the system's limitations in mind.

    """
    return _libsbml.parseL3Formula(formula)

def parseL3FormulaWithModel(formula, model):
    """
    parseL3FormulaWithModel(char const * formula, Model model) -> ASTNode


    Parses a text string as a mathematical formula using a Model to
    resolve symbols, and returns an AST representation of the result.

    This is identical to parseL3Formula(), except that this function uses
    the given model in the argument 'model' to check against identifiers
    that appear in the 'formula'.  For more information about the parser,
    please see the definition of L3ParserSettings and the function
    parseL3Formula().

    Parameter 'formula' is the mathematical formula expression to be
    parsed.

    Parameter 'model' is the Model object to use for checking identifiers.

    Returns the root node of an AST representing the mathematical formula,
    or 'None' if an error occurred while parsing the formula.  When 'None'
    is returned, an error is recorded internally; information about the
    error can be retrieved using getLastParseL3Error().

    See also parseL3Formula(), parseL3FormulaWithSettings(),
    parseL3FormulaWithModel(), parseFormula(), getLastParseL3Error(),
    L3ParserSettings.

    """
    return _libsbml.parseL3FormulaWithModel(formula, model)

def parseL3FormulaWithSettings(formula, settings):
    """
    parseL3FormulaWithSettings(char const * formula, L3ParserSettings settings) -> ASTNode


    Parses a text string as a mathematical formula using specific parser
    settings and returns an AST representation of the result.

    This is identical to parseL3Formula(), except that this function uses
    the parser settings given in the argument 'settings'.  The settings
    override the default parsing behavior.  The following parsing
    behaviors can be configured:

    * A Model object may optionally be provided to use identifiers
    (values of type 'SId)' from the model in preference to pre-defined
    MathML symbols More precisely, the Model entities whose identifiers
    will shadow identical symbols in the mathematical formula are:
    Species, Compartment, Parameter, Reaction, and SpeciesReference.  For
    instance, if the parser is given a Model containing a Species with the
    identifier "pi", and the formula to be parsed is "3*pi", the
    MathML produced by the parser will contain the construct <ci> pi </ci>
    instead of the construct <pi/>.  Another example, if the passed-in
    Model contains a FunctionDefinition with the identifier "sin", that
    function will be used instead of the predefined MathML function
    <sin/>.

    * The function 'log' with a single argument ("log(x)") can be
    parsed as log10(x), ln(x), or treated as an error, as desired.

    * Unary minus signs can be either collapsed or preserved; that is,
    the parser can either (1) remove sequential pairs of unary minuses
    (e.g., "- -3") from the input and incorporate single unary minuses
    into the number node, or (2) preserve all minuses in the AST node
    structure, turning them into ASTNode objects of type AST_MINUS.

    * The character sequence "number id" can be interpreted as a
    numerical value 'number' followed by units of measurement indicated by
    'id,' or it can be treated as a syntax error.  (In Level 3, MathML
    <cn> elements can have an attribute named 'units' placed in the SBML
    namespace, which can be used to indicate the units to be associated
    with the number.  The text-string infix formula parser allows units to
    be placed after raw numbers; they are interpreted as unit identifiers
    for units defined by the SBML specification or in the containing Model
    object.)

    * The symbol 'avogadro' can be parsed either as a MathML csymbol or
    as a identifier.  More specifically, "avogadro" can be treated as an
    ASTNode of type AST_NAME_AVOGADRO or of type AST_NAME.

    * Strings that match built-in functions and constants can either be
    parsed as a match regardless of capitalization, or may be required to
    be all-lower-case to be considered a match.

    * LibSBML plug-ins implementing support for SBML Level 3 packages
    may introduce extensions to the syntax understood by the parser.  The
    precise nature of the extensions will be documented by the individual
    package plug-ins.  An example of a possible extension is a notation
    for vectors and arrays, introduced by the SBML Level 3 Arrays package.

    For more details about the parser, please see the definition of
    L3ParserSettings and parseL3FormulaWithSettings().

    Parameter 'formula' is the mathematical formula expression to be
    parsed.

    Parameter 'settings' is the settings to be used for this parser
    invocation.

    Returns the root node of an AST representing the mathematical formula,
    or 'None' if an error occurred while parsing the formula.  When 'None'
    is returned, an error is recorded internally; information about the
    error can be retrieved using getLastParseL3Error().

    See also parseL3Formula(), parseL3FormulaWithSettings(),
    parseL3FormulaWithModel(), parseFormula(), getLastParseL3Error(),
    L3ParserSettings.

    """
    return _libsbml.parseL3FormulaWithSettings(formula, settings)

def getDefaultL3ParserSettings():
    """
    getDefaultL3ParserSettings() -> L3ParserSettings


    Returns a copy of the default Level 3 ('L3') formula parser settings.

    The data structure storing the settings allows callers to change the
    following parsing behaviors:

    The text-string form of mathematical formulas read by the function
    parseL3Formula() and written by the function formulaToL3String() uses
    an expanded version of the syntax read and written by parseFormula()
    and formulaToString(), respectively.  The latter two libSBML functions
    were originally developed to support conversion between SBML Levels 1
    and 2, and were focused on the syntax of mathematical formulas used in
    SBML Level 1.  With time, and the use of MathML in SBML Levels 2 and
    3, it became clear that supporting Level 2 and 3's expanded
    mathematical syntax would be useful for software developers.  To
    maintain backwards compatibility for libSBML users, the original
    formulaToString() and parseFormula() have been left untouched, and
    instead, the new functionality is provided in the form of
    parseL3Formula() and formulaToL3String().

    The following lists the main differences in the formula syntax
    supported by the Level 3 ('L3') versions of the formula parsers and
    formatters, compared to what is supported by the Level 1-oriented
    parseFormula() and formulaToString():

    * Units may be asociated with bare numbers, using the following
    syntax:

    number unit

    The number may be in any form (an integer, real, or rational number),
    and the unit must conform to the syntax of an SBML identifier
    (technically, the type defined as 'SId' in the SBML specifications).
    The whitespace between number and unit is optional.

    * The Boolean function symbols '&&' (and), '||' (or), '!' (not),
    and '!=' (not equals) may be used.

    * The modulo operation is allowed as the symbol '%' and will
    produce a <piecewise> function in the corresponding MathML output by
    default, or can produce the MathML function 'rem,'  depending on the
    L3ParserSettings object (see  L3ParserSettings_setParseModuloL3v2() ).

    * All inverse trigonometric functions may be defined in the infix
    either using 'arc' as a prefix or simply 'a;' in other words, both
    'arccsc' and 'acsc' are interpreted as the operator arccosecant as
    defined in MathML 2.0.  (Many functions in the simpler SBML Level 1
    oriented parser implemented by parseFormula() are defined this way as
    well, but not all.)

    * The following expression is parsed as a rational number instead
    of as a numerical division:

      (integer/integer)

    Spaces are not allowed in this construct; in other words, "(3 / 4)"
    (with whitespace between the numbers and the operator) will be parsed
    into the MathML <divide> construct rather than a rational number.  You
    can, however, assign units to a rational number as a whole; here is an
    example: "(3/4) ml". (In the case of division rather than a rational
    number, units are not interpreted in this way.)

    * Various parser and formatter behaviors may be altered through
    the use of a L3ParserSettings object in conjunction with the functions
    parseL3FormulaWithSettings() and formulaToL3StringWithSettings() The
    settings available include the following:

    * The function 'log' with a single argument ("log(x)") can be parsed
    as log10(x), ln(x), or treated as an error, as desired.

    * Unary minus signs can be collapsed or preserved; that is, sequential
    pairs of unary minuses (e.g., "- -3") can be removed from the input
    entirely and single unary minuses can be incorporated into the number
    node, or all minuses can be preserved in the AST node structure.

    * Parsing of units embedded in the input string can be turned on and
    off.

    * The string 'avogadro' can be parsed as a MathML csymbol or as an
    identifier.

    * The string % can be parsed either as a  piecewise function or as the
    'rem' function:  a % b will either become

    piecewise(a - b*ceil(a/b), xor((a < 0), (b < 0)), a - b*floor(a/b))

    or

    rem(a, b).

    The latter is simpler, but the 'rem' MathML is only allowed as of SBML
    Level 3 Version 2.* A Model object may optionally be provided to the
    parser using the variant function call parseL3FormulaWithModel() or
    stored in a L3ParserSettings object passed to the variant function
    parseL3FormulaWithSettings().  When a Model object is provided,
    identifiers (values of type 'SId' ) from that model are used in
    preference to pre-defined MathML definitions for both symbols and
    functions. More precisely:

    * In the case of symbols: the Model entities whose identifiers will
    shadow identical symbols in the mathematical formula are: Species,
    Compartment, Parameter, Reaction, and SpeciesReference.  For instance,
    if the parser is given a Model containing a Species with the
    identifier "pi", and the formula to be parsed is "3*pi", the
    MathML produced will contain the construct <ci> pi </ci> instead of
    the construct <pi/>.

    * In the case of user-defined functions: when a Model object is
    provided, 'SId' values of user-defined functions present in the model
    will be used preferentially over pre-defined MathML functions.  For
    example, if the passed-in Model contains a FunctionDefinition object
    with the identifier "sin", that function will be used instead of the
    predefined MathML function <sin/>.

    * An SBMLNamespaces object may optionally be provided to identify
    SBML Level 3 packages that extend the syntax understood by the formula
    parser.  When the namespaces are provided, the parser will interpret
    possible additional syntax defined by the libSBML plug-ins
    implementing the SBML Level 3 packages; for example, it may understand
    vector/array extensions introduced by the SBML Level 3 Arrays package.
    These configuration settings cannot be changed directly using the
    basic parser and formatter functions, but can be changed on a per-call
    basis by using the alternative functions parseL3FormulaWithSettings()
    and formulaToL3StringWithSettings().

    Neither SBML nor the MathML standard define a 'string-form' equivalent
    to MathML expressions.  The approach taken by libSBML is to start with
    the formula syntax defined by SBML Level 1 (which in fact used a
    custom text-string representation of formulas, and not MathML), and
    expand it to include the functionality described above.  This formula
    syntax is based mostly on C programming syntax, and may contain
    operators, function calls, symbols, and white space characters.  The
    following table provides the precedence rules for the different
    entities that may appear in formula strings.

      +----------------------+--------------------------+---------+---------+--------+
      | Token                | Operation                | Class   | Preced. | Assoc. |
      +----------------------+--------------------------+---------+---------+--------+
      | name                 | symbol reference         | operand | 8       | n/a    |
      | (expression)         | expression grouping      | operand | 8       | n/a    |
      | f(...)               | function call            | prefix  | 8       | left   |
      | ^                    | power                    | binary  | 7       | left   |
      | -, !                 | negation, Boolean 'not'  | unary   | 6       | right  |
      | *, /, %              | multip., div., modulo    | binary  | 5       | left   |
      | +, -                 | addition and subtraction | binary  | 4       | left   |
      | ==, <, >, <=, >=, != | Boolean comparisons      | binary  | 3       | left   |
      | &&, ||               | Boolean 'and' and 'or'   | binary  | 2       | left   |
      | ,                    | argument delimiter       | binary  | 1       | left   |
      +----------------------+--------------------------+---------+---------+--------+

    In the table above, operand implies the construct is an operand,
    prefix implies the operation is applied to the following arguments,
    unary implies there is one argument, and binary implies there are two
    arguments.  The values in the Precedence column show how the order of
    different types of operation are determined.  For example, the
    expression a + b * c is evaluated as a + (b * c) because the '*'
    operator has higher precedence.  The Associates column shows how the
    order of similar precedence operations is determined; for example, a
    && b || c is evaluated as (a && b) || c because the '&&' and '||'
    operators are left-associative and have the same precedence.

    The function call syntax consists of a function name, followed by
    optional white space, followed by an opening parenthesis token,
    followed by a sequence of zero or more arguments separated by commas
    (with each comma optionally preceded and/or followed by zero or more
    white space characters), followed by a closing parenthesis token.  The
    function name must be chosen from one of the pre-defined functions in
    SBML or a user-defined function in the model.  The following table
    lists the names of certain common mathematical functions; this table
    corresponds to Table 6 in the SBML Level 1 Version 2 specification
    with additions based on the functions added in SBML Level 2 and Level
    3:

      +----------------+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------+--------------------+
      | Name           | Argument(s)                 | Formula or meaning                                                                                                                                                                    | Argument Constraints             | Result constraints |
      +----------------+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------+--------------------+
      | abs            | x                           | Absolute value of x.                                                                                                                                                                  |                                  |                    |
      | acos, arccos   | x                           | Arccosine of x in radians.                                                                                                                                                            | -1.0 <= x <= 1.0                 | 0 <= acos(x) <= Pi |
      | acosh, arccosh | x                           | Hyperbolic arccosine of x in radians.                                                                                                                                                 |                                  |                    |
      | acot, arccot   | x                           | Arccotangent of x in radians.                                                                                                                                                         |                                  |                    |
      | acoth, arccoth | x                           | Hyperbolic arccotangent of x in radians.                                                                                                                                              |                                  |                    |
      | acsc, arccsc   | x                           | Arccosecant of x in radians.                                                                                                                                                          |                                  |                    |
      | acsch, arccsch | x                           | Hyperbolic arccosecant of x in radians.                                                                                                                                               |                                  |                    |
      | asec, arcsec   | x                           | Arcsecant of x in radians.                                                                                                                                                            |                                  |                    |
      | asech, arcsech | x                           | Hyperbolic arcsecant of x in radians.                                                                                                                                                 |                                  |                    |
      | asin, arcsin   | x                           | Arcsine of x in radians.                                                                                                                                                              | -1.0 <= x <= 1.0                 | 0 <= asin(x) <= Pi |
      | atan, arctan   | x                           | Arctangent of x in radians.                                                                                                                                                           |                                  | 0 <= atan(x) <= Pi |
      | atanh, arctanh | x                           | Hyperbolic arctangent of x in radians.                                                                                                                                                |                                  |                    |
      | ceil, ceiling  | x                           | Smallest number not less than x whose value is an exact integer.                                                                                                                      |                                  |                    |
      | cos            | x                           | Cosine of x                                                                                                                                                                           |                                  |                    |
      | cosh           | x                           | Hyperbolic cosine of x.                                                                                                                                                               |                                  |                    |
      | cot            | x                           | Cotangent of x.                                                                                                                                                                       |                                  |                    |
      | coth           | x                           | Hyperbolic cotangent of x.                                                                                                                                                            |                                  |                    |
      | csc            | x                           | Cosecant of x.                                                                                                                                                                        |                                  |                    |
      | csch           | x                           | Hyperbolic cosecant of x.                                                                                                                                                             |                                  |                    |
      | delay          | x, y                        | The value of x at y time units in the past.                                                                                                                                           |                                  |                    |
      | factorial      | n                           | The factorial of n. Factorials are defined by n! = n*(n-1)* ... * 1.                                                                                                                  | n must be an integer.            |                    |
      | exp            | x                           | e^x, where e is the base of the natural logarithm.                                                                                                                                    |                                  |                    |
      | floor          | x                           | The largest number not greater than x whose value is an exact integer.                                                                                                                |                                  |                    |
      | ln             | x                           | Natural logarithm of x.                                                                                                                                                               | x > 0                            |                    |
      | log            | x                           | By default, the base 10 logarithm of x, but can be set to be the natural logarithm of x, or to be an illegal construct.                                                               | x > 0                            |                    |
      | log            | x, y                        | The base x logarithm of y.                                                                                                                                                            | y > 0                            |                    |
      | log10          | x                           | Base 10 logarithm of x.                                                                                                                                                               | x > 0                            |                    |
      | piecewise      | x1, y1, [x2, y2,] [...] [z] | A piecewise function: if (y1), x1.  Otherwise, if (y2), x2, etc.  Otherwise, z.                                                                                                       | y1, y2, y3 [etc] must be Boolean |                    |
      | pow, power     | x, y                        | x^y.                                                                                                                                                                                  |                                  |                    |
      | root           | b, x                        | The root base b of x.                                                                                                                                                                 |                                  |                    |
      | sec            | x                           | Secant of x.                                                                                                                                                                          |                                  |                    |
      | sech           | x                           | Hyperbolic secant of x.                                                                                                                                                               |                                  |                    |
      | sqr            | x                           | x^2.                                                                                                                                                                                  |                                  |                    |
      | sqrt           | x                           | &radic;x.                                                                                                                                                                             | x > 0                            | sqrt(x) >= 0       |
      | sin            | x                           | Sine of x.                                                                                                                                                                            |                                  |                    |
      | sinh           | x                           | Hyperbolic sine of x.                                                                                                                                                                 |                                  |                    |
      | tan            | x                           | Tangent of x.                                                                                                                                                                         | x != n*Pi/2, for odd integer n   |                    |
      | tanh           | x                           | Hyperbolic tangent of x.                                                                                                                                                              |                                  |                    |
      | and            | x, y, z...                  | Boolean and(x, y, z...): returns true if all of its arguments are true.  Note that and is an n-ary function, taking 0 or more arguments, and that and() returns true.                 | All arguments must be Boolean    |                    |
      | not            | x                           | Boolean not(x)                                                                                                                                                                        | x must be Boolean                |                    |
      | or             | x, y, z...                  | Boolean or(x, y, z...): returns true if at least one of its arguments is true.  Note that or is an n-ary function, taking 0 or more arguments, and that or() returns false.           | All arguments must be Boolean    |                    |
      | xor            | x, y, z...                  | Boolean xor(x, y, z...): returns true if an odd number of its arguments is true.  Note that xor is an n-ary function, taking 0 or more arguments, and that xor() returns false.       | All arguments must be Boolean    |                    |
      | eq             | x, y, z...                  | Boolean eq(x, y, z...): returns true if all arguments are equal.  Note that eq is an n-ary function, but must take 2 or more arguments.                                               |                                  |                    |
      | geq            | x, y, z...                  | Boolean geq(x, y, z...): returns true if each argument is greater than or equal to the argument following it.  Note that geq is an n-ary function, but must take 2 or more arguments. |                                  |                    |
      | gt             | x, y, z...                  | Boolean gt(x, y, z...): returns true if each argument is greater than the argument following it.  Note that gt is an n-ary function, but must take 2 or more arguments.               |                                  |                    |
      | leq            | x, y, z...                  | Boolean leq(x, y, z...): returns true if each argument is less than or equal to the argument following it.  Note that leq is an n-ary function, but must take 2 or more arguments.    |                                  |                    |
      | lt             | x, y, z...                  | Boolean lt(x, y, z...): returns true if each argument is less than the argument following it.  Note that lt is an n-ary function, but must take 2 or more arguments.                  |                                  |                    |
      | neq            | x, y                        | Boolean x != y: returns true unless x and y are equal.                                                                                                                                |                                  |                    |
      | plus           | x, y, z...                  | x + y + z + ...: The sum of the arguments of the function.  Note that plus is an n-ary function taking 0 or more arguments, and that plus() returns 0.                                |                                  |                    |
      | times          | x, y, z...                  | x * y * z * ...: The product of the arguments of the function.  Note that times is an n-ary function taking 0 or more arguments, and that times() returns 1.                          |                                  |                    |
      | minus          | x, y                        | x - y.                                                                                                                                                                                |                                  |                    |
      | divide         | x, y                        | x / y.                                                                                                                                                                                |                                  |                    |
      +----------------+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------+--------------------+

    Parsing of the various MathML functions and constants are all case-
    insensitive by default: function names such as cos, Cos and COS are
    all parsed as the MathML cosine operator, <cos>.  However, when a
    Model object is used in conjunction with either
    parseL3FormulaWithModel() or parseL3FormulaWithSettings(), any
    identifiers found in that model will be parsed in a case-sensitive
    way.  For example, if a model contains a Species having the identifier
    Pi, the parser will parse "Pi" in the input as "<ci> Pi </ci>" but
    will continue to parse the symbols "pi" and "PI" as "<pi>".

    As mentioned above, the manner in which the 'L3' versions of the
    formula parser and formatter interpret the function "log" can be
    changed.  To do so, callers should use the function
    parseL3FormulaWithSettings() and pass it an appropriate
    L3ParserSettings object.  By default, unlike the SBML Level 1 parser
    implemented by parseFormula(), the string "log" is interpreted as
    the base 10 logarithm, and not as the natural logarithm.  However, you
    can change the interpretation to be base-10 log, natural log, or as an
    error; since the name 'log' by itself is ambiguous, you require that
    the parser uses 'log10' or 'ln' instead, which are more clear.  Please
    refer to parseL3FormulaWithSettings().

    In addition, the following symbols will be translated to their MathML
    equivalents, if no symbol with the same 'SId' identifier string exists
    in the Model object provided:

      +-----------------+-------------------------------------------------+--------------------------------------------------------------------------------------------------------------+
      | Name            | Meaning                                         | MathML                                                                                                       |
      +-----------------+-------------------------------------------------+--------------------------------------------------------------------------------------------------------------+
      | true            | Boolean value true                              | <true/>                                                                                                      |
      | false           | Boolean value false                             | <false/>                                                                                                     |
      | pi              | Mathematical constant pi                        | <pi/>                                                                                                        |
      | avogadro        | Value of Avogadro's constant stipulated by SBML | <csymbol encoding="text" definitionURL="http://www.sbml.org/sbml/symbols/avogadro"> avogadro </csymbol/> |
      | time            | Simulation time as defined in SBML              | <csymbol encoding="text" definitionURL="http://www.sbml.org/sbml/symbols/time"> time </csymbol/>         |
      | inf, infinity   | Mathematical constant "infinity"              | <infinity/>                                                                                                  |
      | nan, notanumber | Mathematical concept "not a number"           | <notanumber/>                                                                                                |
      +-----------------+-------------------------------------------------+--------------------------------------------------------------------------------------------------------------+

    Again, as mentioned above, whether the string "avogadro" is parsed
    as an AST node of type AST_NAME_AVOGADRO or AST_NAME is configurable;
    use the version of the parser function called
    parseL3FormulaWithSettings().  This Avogadro-related functionality is
    provided because SBML Level 2 models may not use AST_NAME_AVOGADRO AST
    nodes.

    For more details about the parser, please see the definition of
    L3ParserSettings and parseL3Formula().

    See also parseL3Formula(), parseL3FormulaWithSettings(),
    formulaToL3StringWithSettings(), L3ParserSettings.

    """
    return _libsbml.getDefaultL3ParserSettings()

def getLastParseL3Error():
    """
    getLastParseL3Error() -> char *


    Returns the last error reported by the 'L3' mathematical formula
    parser.

    If the functions parseL3Formula(), parseL3FormulaWithSettings(), or
    parseL3FormulaWithModel() return 'None,' an error is set internally.
    This function allows callers to retrieve information about the error.

    Returns a string describing the error that occurred.  This will
    contain the input string the parser was trying to parse, the character
    it had parsed when it encountered the error, and a description of the
    error.

    See also parseL3Formula(), parseL3FormulaWithSettings(),
    parseL3FormulaWithModel(), getDefaultL3ParserSettings().

    """
    return _libsbml.getLastParseL3Error()

def SBML_deleteL3Parser():
    """
    SBML_deleteL3Parser()


    Internal implementation method.

    """
    return _libsbml.SBML_deleteL3Parser()
L3P_PARSE_LOG_AS_LOG10 = _libsbml.L3P_PARSE_LOG_AS_LOG10
L3P_PARSE_LOG_AS_LN = _libsbml.L3P_PARSE_LOG_AS_LN
L3P_PARSE_LOG_AS_ERROR = _libsbml.L3P_PARSE_LOG_AS_ERROR
L3P_COLLAPSE_UNARY_MINUS = _libsbml.L3P_COLLAPSE_UNARY_MINUS
L3P_EXPAND_UNARY_MINUS = _libsbml.L3P_EXPAND_UNARY_MINUS
L3P_PARSE_UNITS = _libsbml.L3P_PARSE_UNITS
L3P_NO_UNITS = _libsbml.L3P_NO_UNITS
L3P_AVOGADRO_IS_CSYMBOL = _libsbml.L3P_AVOGADRO_IS_CSYMBOL
L3P_AVOGADRO_IS_NAME = _libsbml.L3P_AVOGADRO_IS_NAME
L3P_COMPARE_BUILTINS_CASE_INSENSITIVE = _libsbml.L3P_COMPARE_BUILTINS_CASE_INSENSITIVE
L3P_COMPARE_BUILTINS_CASE_SENSITIVE = _libsbml.L3P_COMPARE_BUILTINS_CASE_SENSITIVE
L3P_MODULO_IS_REM = _libsbml.L3P_MODULO_IS_REM
L3P_MODULO_IS_PIECEWISE = _libsbml.L3P_MODULO_IS_PIECEWISE
L3P_PARSE_L3V2_FUNCTIONS_DIRECTLY = _libsbml.L3P_PARSE_L3V2_FUNCTIONS_DIRECTLY
L3P_PARSE_L3V2_FUNCTIONS_AS_GENERIC = _libsbml.L3P_PARSE_L3V2_FUNCTIONS_AS_GENERIC
L3P_PARSE_PACKAGE_MATH_DIRECTLY = _libsbml.L3P_PARSE_PACKAGE_MATH_DIRECTLY
L3P_PARSE_PACKAGE_MATH_AS_GENERIC = _libsbml.L3P_PARSE_PACKAGE_MATH_AS_GENERIC
INFIX_SYNTAX_NAMED_SQUARE_BRACKETS = _libsbml.INFIX_SYNTAX_NAMED_SQUARE_BRACKETS
INFIX_SYNTAX_CURLY_BRACES = _libsbml.INFIX_SYNTAX_CURLY_BRACES
INFIX_SYNTAX_CURLY_BRACES_SEMICOLON = _libsbml.INFIX_SYNTAX_CURLY_BRACES_SEMICOLON
class L3ParserSettings(_object):
    """

    Controls the behavior of the Level 3 formula parser.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    The function parseL3FormulaWithSettings(), along with its variants
    parseL3Formula() and parseL3FormulaWithModel(), are the interfaces to
    a parser for mathematical formulas written as text strings.  The
    inverse function is formulaToL3String() and its variants such as
    formulaToL3StringWithSettings(). The parsers and the formula writers
    convert between a text-string representation of mathematical formulas
    and Abstract Syntax Trees (ASTs), represented in libSBML using ASTNode
    objects. Compared to the parser and writer implemented by the
    functions parseFormula() and formulaToString(), which were designed
    primarily for converting the mathematical formula strings in SBML
    Level 1, the SBML Level 3 or 'L3' variants of the parser and writer
    use an extended formula syntax.  They also have a number of
    configurable behaviors.  This class (L3ParserSettings) is an object
    used to communicate the configuration settings with callers.

    The following aspects of the parser are configurable using
    L3ParserSettings objects.  (For the formula writer, only a subset of
    these settings is relevant; please see the documentation for
    formulaToL3StringWithSettings() for more information about which
    ones).

    * A Model object may optionally be provided to use identifiers
    (values of type 'SId)' from the model in preference to pre-defined
    MathML symbols More precisely, the Model entities whose identifiers
    will shadow identical symbols in the mathematical formula are:
    Species, Compartment, Parameter, Reaction, and SpeciesReference.  For
    instance, if the parser is given a Model containing a Species with the
    identifier "pi", and the formula to be parsed is "3*pi", the
    MathML produced by the parser will contain the construct <ci> pi </ci>
    instead of the construct <pi/>.  Another example, if the passed-in
    Model contains a FunctionDefinition with the identifier "sin", that
    function will be used instead of the predefined MathML function
    <sin/>.

    * The function 'log' with a single argument ("log(x)") can be
    parsed as log10(x), ln(x), or treated as an error, as desired.

    * Unary minus signs can be either collapsed or preserved; that is,
    the parser can either (1) remove sequential pairs of unary minuses
    (e.g., "- -3") from the input and incorporate single unary minuses
    into the number node, or (2) preserve all minuses in the AST node
    structure, turning them into ASTNode objects of type AST_MINUS.

    * The character sequence "number id" can be interpreted as a
    numerical value 'number' followed by units of measurement indicated by
    'id,' or it can be treated as a syntax error.  (In Level 3, MathML
    <cn> elements can have an attribute named 'units' placed in the SBML
    namespace, which can be used to indicate the units to be associated
    with the number.  The text-string infix formula parser allows units to
    be placed after raw numbers; they are interpreted as unit identifiers
    for units defined by the SBML specification or in the containing Model
    object.)

    * The symbol 'avogadro' can be parsed either as a MathML csymbol or
    as a identifier.  More specifically, "avogadro" can be treated as an
    ASTNode of type AST_NAME_AVOGADRO or of type AST_NAME.

    * Strings that match built-in functions and constants can either be
    parsed as a match regardless of capitalization, or may be required to
    be all-lower-case to be considered a match.

    * LibSBML plug-ins implementing support for SBML Level 3 packages
    may introduce extensions to the syntax understood by the parser.  The
    precise nature of the extensions will be documented by the individual
    package plug-ins.  An example of a possible extension is a notation
    for vectors and arrays, introduced by the SBML Level 3 Arrays package.

    To obtain the default configuration values, callers can use the
    function getDefaultL3ParserSettings().  To change the configuration,
    callers can create an L3ParserSettings object, set the desired
    characteristics using the methods provided, and pass that object to
    parseL3FormulaWithSettings().

    See also parseL3Formula(), parseL3FormulaWithSettings(),
    parseL3FormulaWithModel(), parseFormula(),
    formulaToL3StringWithSettings(), formulaToL3String(),
    formulaToString(), getDefaultL3ParserSettings().

    """

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, L3ParserSettings, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, L3ParserSettings, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(L3ParserSettings self) -> L3ParserSettings
        __init__(L3ParserSettings self, Model model, ParseLogType_t parselog, bool collapseminus, bool parseunits, bool avocsymbol, bool caseSensitive=False, SBMLNamespaces sbmlns=None, bool moduloL3v2=False, bool l3v2functions=False) -> L3ParserSettings
        __init__(L3ParserSettings self, Model model, ParseLogType_t parselog, bool collapseminus, bool parseunits, bool avocsymbol, bool caseSensitive=False, SBMLNamespaces sbmlns=None, bool moduloL3v2=False) -> L3ParserSettings
        __init__(L3ParserSettings self, Model model, ParseLogType_t parselog, bool collapseminus, bool parseunits, bool avocsymbol, bool caseSensitive=False, SBMLNamespaces sbmlns=None) -> L3ParserSettings
        __init__(L3ParserSettings self, Model model, ParseLogType_t parselog, bool collapseminus, bool parseunits, bool avocsymbol, bool caseSensitive=False) -> L3ParserSettings
        __init__(L3ParserSettings self, Model model, ParseLogType_t parselog, bool collapseminus, bool parseunits, bool avocsymbol) -> L3ParserSettings
        __init__(L3ParserSettings self, L3ParserSettings source) -> L3ParserSettings


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            L3ParserSettings()

        Creates a new L3ParserSettings object with default values.

        This is the default constructor for the L3ParserSettings object.  It
        sets the stored Model object to 'None' and sets the following field
        values in the L3ParserSettings object:

        * parseunits ('parse units') is set to L3P_PARSE_UNITS.

        * collapseminus ('collapse minus') is set to
        L3P_EXPAND_UNARY_MINUS.

        * parselog ('parse log') is set to L3P_PARSE_LOG_AS_LOG10.

        * avocsymbol ('Avogadro csymbol') is set to
        L3P_AVOGADRO_IS_CSYMBOL.

        * caseSensitive ('case sensitive') is set to
        L3P_COMPARE_BUILTINS_CASE_INSENSITIVE.

        * moduloL3v2 ('modulo l3v2') is set to L3P_MODULO_IS_PIECEWISE.

        * sbmlns ('SBML namespaces') is set to 'None' (which indicates
        that no syntax extensions due to SBML Level 3 packages will be assumed
        ---the formula parser will only understand the core syntax described
        in the documentation for parseL3Formula()).

        ______________________________________________________________________
        Method variant with the following signature:

            L3ParserSettings(L3ParserSettings source)

        Copy constructor.

        Parameter 'source' is the instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            L3ParserSettings(Model model, ParseLogType_t parselog, bool
        collapseminus, bool parseunits, bool avocsymbol, bool caseSensitive =
        false, SBMLNamespaces sbmlns = None, bool moduloL3v2 = false, bool
        l3v2functions = false)

        Creates a new L3ParserSettings object with specific values for all
        possible settings.

        Parameter 'model' is a Model object to be used for disambiguating
        identifiers encountered by parseL3FormulaWithSettings() in
        mathematical formulas.

        Parameter 'parselog' is ('parse log') a flag that controls how the
        parser will handle the symbol 'log' in mathematical formulas. The
        function 'log' with a single argument ("log(x)") can be parsed as
        log10(x), ln(x), or treated as an error, as desired, by using the
        parameter values L3P_PARSE_LOG_AS_LOG10, L3P_PARSE_LOG_AS_LN, or
        L3P_PARSE_LOG_AS_ERROR, respectively.

        Parameter 'collapseminus' is ('collapse minus') a flag that controls
        how the parser will handle minus signs in formulas.  Unary minus signs
        can be collapsed or preserved; that is, sequential pairs of unary
        minuses (e.g., "- -3") can be removed from the input entirely and
        single unary minuses can be incorporated into the number node, or all
        minuses can be preserved in the AST node structure. The possible
        values of this field are L3P_COLLAPSE_UNARY_MINUS (to collapse unary
        minuses) and L3P_EXPAND_UNARY_MINUS (to expand unary minuses).

        Parameter 'parseunits' is ('parse units') a flag that controls how the
        parser will handle apparent references to units of measurement
        associated with raw numbers in a formula.  If set to the value
        L3P_PARSE_UNITS, units are parsed; if set to the value L3P_NO_UNITS,
        units are not parsed.

        Parameter 'avocsymbol' is ('Avogadro csymbol') a flag that controls
        how the parser will handle the appearance of the symbol 'avogadro' in
        a formula.  If set to the value L3P_AVOGADRO_IS_CSYMBOL, the symbol is
        interpreted as the SBML/MathML csymbol 'avogadro;' if set to the value
        L3P_AVOGADRO_IS_NAME, the symbol is interpreted as a plain symbol
        name.

        Parameter 'caseSensitive' is ('case sensitive') a flag that controls
        how the cases of alphabetical characters are treated when symbols are
        compared. If the flag is set to the value
        L3P_COMPARE_BUILTINS_CASE_INSENSITIVE, symbols are compared in a case-
        insensitive manner, which means that mathematical functions such as
        ''sin'' will be matched no matter what their case is: ''Sin','
        ''SIN',' etc.  If the flag is set to the value
        L3P_COMPARE_BUILTINS_CASE_SENSITIVE, symbols are interpreted in a
        case-sensitive manner.

        Parameter 'modulol3v2' is ('modulo l3v2') a flag that controls how the
        parser will handle the '%' ('modulo') symbol in formulas.  By default,
        the parser will convert 'a % b' to a piecewise function that properly
        calculates the remainder of a with respect to be, but the parser can
        also be set to produce the MathML 'rem' function, should the target of
        the produced ASTNode be an SBML Level 3 Version 2  document, where the
        'rem' function is legal. The possible values of this field are
        L3P_MODULO_IS_PIECEWISE (to parse '%' as a piecewise function) and
        L3P_MODULO_IS_REM (to parse '%' as 'rem).'

        Parameter 'sbmlns' is ('SBML namespaces') an SBML namespaces object.
        The namespaces identify the SBML Level 3 packages that can extend the
        syntax understood by the formula parser.  When non-'None,' the parser
        will interpret additional syntax defined by the packages; for example,
        it may understand vector/array extensions introduced by the SBML Level
        3 Arrays package.

        </dl><dl class="docnote"><dt>Documentation note:</dt><dd> 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 and C#, 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 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. </dd></dl>

        See also getModel(), setModel(), unsetModel(), getParseLog(),
        setParseLog(), getParseUnits(), setParseUnits(),
        getParseCollapseMinus(), setParseCollapseMinus(),
        getParseAvogadroCsymbol(), setParseAvogadroCsymbol(),
        getParseModuloL3v2(), setParseModuloL3v2(), getParseL3v2Functions(),
        setParseL3v2Functions().

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        this = _libsbml.new_L3ParserSettings(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_L3ParserSettings
    __del__ = lambda self: None

    def setModel(self, model):
        """
        setModel(L3ParserSettings self, Model model)


        Sets the model reference in this L3ParserSettings object.

        When a Model object is provided, identifiers (values of type 'SId)'
        from that model are used in preference to pre-defined MathML symbol
        definitions.  More precisely, the Model entities whose identifiers
        will shadow identical symbols in the mathematical formula are:
        Species, Compartment, Parameter, Reaction, and SpeciesReference.  For
        instance, if the parser is given a Model containing a Species with the
        identifier "pi", and the formula to be parsed is "3*pi", the
        MathML produced will contain the construct <ci> pi </ci> instead of
        the construct <pi/>.  Similarly, when a Model object is provided,
        'SId' values of user-defined functions present in the Model will be
        used preferentially over pre-defined MathML functions.  For example,
        if the passed-in Model contains a FunctionDefinition with the
        identifier "sin", that function will be used instead of the
        predefined MathML function <sin/>.

        Parameter 'model' is a Model object to be used for disambiguating
        identifiers.

        WARNING:

        This does not copy the Model object. This means that modifications
        made to the Model after invoking this method may affect parsing
        behavior, because the parser will query the current contents of the
        model.

        See also getModel(), unsetModel().

        """
        return _libsbml.L3ParserSettings_setModel(self, model)


    def getModel(self):
        """
        getModel(L3ParserSettings self) -> Model


        Returns the Model object referenced by this L3ParserSettings object.

        When a Model object is provided, identifiers (values of type 'SId)'
        from that model are used in preference to pre-defined MathML symbol
        definitions.  More precisely, the Model entities whose identifiers
        will shadow identical symbols in the mathematical formula are:
        Species, Compartment, Parameter, Reaction, and SpeciesReference.  For
        instance, if the parser is given a Model containing a Species with the
        identifier "pi", and the formula to be parsed is "3*pi", the
        MathML produced will contain the construct <ci> pi </ci> instead of
        the construct <pi/>.  Similarly, when a Model object is provided,
        'SId' values of user-defined functions present in the Model will be
        used preferentially over pre-defined MathML functions.  For example,
        if the passed-in Model contains a FunctionDefinition with the
        identifier "sin", that function will be used instead of the
        predefined MathML function <sin/>.

        See also setModel(), unsetModel().

        """
        return _libsbml.L3ParserSettings_getModel(self)


    def unsetModel(self):
        """
        unsetModel(L3ParserSettings self)


        Unsets the Model reference in this L3ParserSettings object.

        The effect of calling this method is to set the stored model value to
        'None.'

        See also setModel(), getModel().

        """
        return _libsbml.L3ParserSettings_unsetModel(self)


    def setParseLog(self, type):
        """
        setParseLog(L3ParserSettings self, ParseLogType_t type)


        Sets the behavior for handling 'log' in mathematical formulas.

        The function 'log' with a single argument ("log(x)") can be parsed
        as log10(x), ln(x), or treated as an error. These three behaviors are
        set, respectively, by using the value L3P_PARSE_LOG_AS_LOG10,
        L3P_PARSE_LOG_AS_LN, or L3P_PARSE_LOG_AS_ERROR for the 'type'
        parameter.

        Parameter 'type' is a constant, one of following three possibilities:

        * L3P_PARSE_LOG_AS_LOG10

        * L3P_PARSE_LOG_AS_LN

        * L3P_PARSE_LOG_AS_ERROR

        See also getParseLog().

        """
        return _libsbml.L3ParserSettings_setParseLog(self, type)


    def getParseLog(self):
        """
        getParseLog(L3ParserSettings self) -> ParseLogType_t


        Indicates the current behavior set for handling the function 'log'
        with one argument.

        The function 'log' with a single argument ("log(x)") can be parsed
        as log10(x), ln(x), or treated as an error, as desired.  These three
        possible behaviors are indicated, respectively, by the values
        L3P_PARSE_LOG_AS_LOG10, L3P_PARSE_LOG_AS_LN, and
        L3P_PARSE_LOG_AS_ERROR.

        Returns One of following three constants:

        * L3P_PARSE_LOG_AS_LOG10

        * L3P_PARSE_LOG_AS_LN

        * L3P_PARSE_LOG_AS_ERROR

        See also setParseLog().

        """
        return _libsbml.L3ParserSettings_getParseLog(self)


    def setParseCollapseMinus(self, collapseminus):
        """
        setParseCollapseMinus(L3ParserSettings self, bool collapseminus)


        Sets the behavior for handling unary minuses appearing in mathematical
        formulas.

        This setting affects two behaviors.  First, pairs of multiple unary
        minuses in a row (e.g., "- -3") can be collapsed and ignored in the
        input, or the multiple minuses can be preserved in the AST node tree
        that is generated by the parser.  Second, minus signs in front of
        numbers can be collapsed into the number node itself; for example, a
        "- 4.1" can be turned into a single ASTNode of type AST_REAL with a
        value of -4.1, or it can be turned into a node of type AST_MINUS
        having a child node of type AST_REAL.

        This method lets you tell the parser which behavior to use---either
        collapse minuses or always preserve them.  The two possibilities are
        represented using the following constants:

        * L3P_COLLAPSE_UNARY_MINUS (value = 'True):' collapse unary
        minuses where possible.

        * L3P_EXPAND_UNARY_MINUS (value = 'False):' do not collapse unary
        minuses, and instead translate each one into an AST node of type
        AST_MINUS. Parameter 'collapseminus' is a boolean value (one of the
        constants L3P_COLLAPSE_UNARY_MINUS or L3P_EXPAND_UNARY_MINUS)
        indicating how unary minus signs in the input should be handled.

        See also getParseCollapseMinus().

        """
        return _libsbml.L3ParserSettings_setParseCollapseMinus(self, collapseminus)


    def getParseCollapseMinus(self):
        """
        getParseCollapseMinus(L3ParserSettings self) -> bool


        Indicates the current behavior set for handling multiple unary minuses
        in formulas.

        This setting affects two behaviors.  First, pairs of multiple unary
        minuses in a row (e.g., "- -3") can be collapsed and ignored in the
        input, or the multiple minuses can be preserved in the AST node tree
        that is generated by the parser.  Second, minus signs in front of
        numbers can be collapsed into the number node itself; for example, a
        "- 4.1" can be turned into a single ASTNode of type AST_REAL with a
        value of -4.1, or it can be turned into a node of type AST_MINUS
        having a child node of type AST_REAL.

        Returns A boolean indicating the behavior currently set.  The possible
        values are as follows:

        * L3P_COLLAPSE_UNARY_MINUS (value = 'True):' collapse unary minuses
        where possible.

        * L3P_EXPAND_UNARY_MINUS (value = 'False):' do not collapse unary
        minuses, and instead translate each one into an AST node of type
        AST_MINUS. See also setParseCollapseMinus().

        """
        return _libsbml.L3ParserSettings_getParseCollapseMinus(self)


    def setParseUnits(self, units):
        """
        setParseUnits(L3ParserSettings self, bool units)


        Sets the parser's behavior in handling units associated with numbers
        in a mathematical formula.

        In SBML Level 2, there is no means of associating a unit of
        measurement with a pure number in a formula, while SBML Level 3 does
        define a syntax for this.  In Level 3, MathML <cn> elements can have
        an attribute named 'units' placed in the SBML namespace, which can be
        used to indicate the units to be associated with the number.  The
        text-string infix formula parser allows units to be placed after raw
        numbers; they are interpreted as unit identifiers for units defined by
        the SBML specification or in the containing Model object. Some
        examples include: "4 mL", "2.01 Hz", "3.1e-6 M", and "(5/8)
        inches".  To produce a valid SBML model, there must either exist a
        UnitDefinition corresponding to the identifier of the unit, or the
        unit must be defined in Table 2 of the SBML Level 3 specification.

        This method sets the formula parser's behavior with respect to units.

        Parameter 'units' is a boolean indicating whether to parse units.  The
        possible values are as follows:

        * L3P_PARSE_UNITS (value = 'True):' parse units in the text-string
        formula.

        * L3P_NO_UNITS (value = 'False):' treat units in the text-string
        formula as errors. See also getParseUnits().

        """
        return _libsbml.L3ParserSettings_setParseUnits(self, units)


    def getParseUnits(self):
        """
        getParseUnits(L3ParserSettings self) -> bool


        Indicates the current behavior set for handling units in text-string
        mathematical formulas.

        In SBML Level 2, there is no means of associating a unit of
        measurement with a pure number in a formula, while SBML Level 3 does
        define a syntax for this.  In Level 3, MathML <cn> elements can have
        an attribute named 'units' placed in the SBML namespace, which can be
        used to indicate the units to be associated with the number.  The
        text-string infix formula parser allows units to be placed after raw
        numbers; they are interpreted as unit identifiers for units defined by
        the SBML specification or in the containing Model object. Some
        examples include: "4 mL", "2.01 Hz", "3.1e-6 M", and "(5/8)
        inches".  To produce a valid SBML model, there must either exist a
        UnitDefinition corresponding to the identifier of the unit, or the
        unit must be defined in Table 2 of the SBML Level 3 specification.

        Since SBML Level 2 does not have the ability to associate units with
        pure numbers, the value should be expected to be 'False'
        (L3P_NO_UNITS) when parsing text-string formulas intended for use in
        SBML Level 2 documents.

        Returns A boolean indicating whether to parse units.  The possible
        values are as follows:

        * L3P_PARSE_UNITS (value = 'True):' parse units in the text-string
        formula.

        * L3P_NO_UNITS (value = 'False):' treat units in the text-string
        formula as errors. See also setParseUnits().

        """
        return _libsbml.L3ParserSettings_getParseUnits(self)


    def setParseAvogadroCsymbol(self, l2only):
        """
        setParseAvogadroCsymbol(L3ParserSettings self, bool l2only)


        Sets the parser's behavior in handling the symbol 'avogadro' in
        mathematical formulas.

        SBML Level 3 defines a symbol for representing the value of
        Avogadro's constant, but it is not defined in SBML Level 2.  As a
        result, the text-string formula parser must behave differently
        depending on which SBML Level is being targeted.  For Level 3
        documents, it can interpret instances of 'avogadro' in the input as a
        reference to the MathML csymbol for Avogadro's constant defined in the
        SBML Level 3 specification.  For Level 2, it must treat 'avogadro' as
        just another plain symbol.

        This method allows callers to set the avogadro-handling behavior in
        this L3ParserSettings object.  The possible values of 'l2only' are as
        follows:

        * L3P_AVOGADRO_IS_CSYMBOL (value = 'True):' tells the parser to
        translate the string 'avogadro' (in any capitalization) into an AST
        node of type AST_NAME_AVOGADRO.

        * L3P_AVOGADRO_IS_NAME (value = 'False):' tells the parser to
        translate the string 'avogadro' into an AST of type AST_NAME. Since
        SBML Level 2 does not define a symbol for Avogadro's constant, the
        value should be set to L3P_AVOGADRO_IS_NAME when parsing text-string
        formulas intended for use in SBML Level 2 documents.

        Parameter 'l2only' is a boolean value indicating how the string
        'avogadro' should be treated when encountered in a formula.  This will
        be one of the values L3P_AVOGADRO_IS_CSYMBOL or L3P_AVOGADRO_IS_NAME.

        See also getParseAvogadroCsymbol().

        """
        return _libsbml.L3ParserSettings_setParseAvogadroCsymbol(self, l2only)


    def getParseAvogadroCsymbol(self):
        """
        getParseAvogadroCsymbol(L3ParserSettings self) -> bool


        Indicates the current behavior set for handling 'avogadro' for SBML
        Level 3.

        SBML Level 3 defines a symbol for representing the value of
        Avogadro's constant, but it is not defined in SBML Level 2.  As a
        result, the text-string formula parser must behave differently
        depending on which SBML Level is being targeted.  For Level 3
        documents, it can interpret instances of 'avogadro' in the input as a
        reference to the MathML csymbol for Avogadro's constant defined in the
        SBML Level 3 specification.  For Level 2, it must treat 'avogadro' as
        just another plain symbol.

        This method returns the current setting of the avogadro-handling
        behavior in this L3ParserSettings object. The possible values are as
        follows:

        * L3P_AVOGADRO_IS_CSYMBOL (value = 'True):' tells the parser to
        translate the string 'avogadro' (in any capitalization) into an AST
        node of type AST_NAME_AVOGADRO.

        * L3P_AVOGADRO_IS_NAME (value = 'False):' tells the parser to
        translate the string 'avogadro' into an AST of type AST_NAME. Returns
        A boolean indicating which mode is currently set; one of
        L3P_AVOGADRO_IS_CSYMBOL or L3P_AVOGADRO_IS_NAME.

        See also setParseAvogadroCsymbol().

        """
        return _libsbml.L3ParserSettings_getParseAvogadroCsymbol(self)


    def setComparisonCaseSensitivity(self, strcmp):
        """
        setComparisonCaseSensitivity(L3ParserSettings self, bool strcmp)


        Sets the parser's behavior with respect to case sensitivity for
        recognizing predefined symbols.

        By default (which is the value
        L3P_COMPARE_BUILTINS_CASE_INSENSITIVE), the parser compares symbols in
        a case insensitive manner for built-in functions such as ''sin'' and
        ''piecewise',' and for constants such as ''True'' and ''avogadro'.'
        Setting this option to L3P_COMPARE_BUILTINS_CASE_SENSITIVE causes the
        parser to become case sensitive.  In that mode, for example, the
        symbols ''sin'' and ''True'' will match the built-in values, but the
        symbols ''SIN',' ''Sin',' ''True',' ''TRUE',' and so on, will not.

        Parameter 'strcmp' is a boolean indicating whether to be case
        sensitive (if 'True)' or be case insensitive (if 'False).'

        See also getComparisonCaseSensitivity().

        """
        return _libsbml.L3ParserSettings_setComparisonCaseSensitivity(self, strcmp)


    def getComparisonCaseSensitivity(self):
        """
        getComparisonCaseSensitivity(L3ParserSettings self) -> bool


        Returns 'True' if the parser is configured to match built-in symbols
        in a case-insensitive way.

        By default (which is the value
        L3P_COMPARE_BUILTINS_CASE_INSENSITIVE), the parser compares symbols in
        a case insensitive manner for built-in functions such as ''sin'' and
        ''piecewise',' and for constants such as ''True'' and ''avogadro'.'
        Setting this option to L3P_COMPARE_BUILTINS_CASE_SENSITIVE causes the
        parser to become case sensitive.  In that mode, for example, the
        symbols ''sin'' and ''True'' will match the built-in values, but the
        symbols ''SIN',' ''Sin',' ''True',' ''TRUE',' and so on, will not.

        Returns 'True' if matches are done in a case-sensitive manner, and
        'False' if the parser will recognize built-in functions and constants
        regardless of case,.

        See also setComparisonCaseSensitivity().

        """
        return _libsbml.L3ParserSettings_getComparisonCaseSensitivity(self)


    def setParseModuloL3v2(self, modulol3v2):
        """
        setParseModuloL3v2(L3ParserSettings self, bool modulol3v2)


        Sets the behavior for handling the '%' sumbol in mathematical
        formulas.

        This setting affects whether the '%' symbol (modulo) is parsed as a
        piecewise equation that returns the modulo value of the entries on
        either side of the symbol, or whether it is parsed as the MathML
        'rem' function, which was allowed in SBML Level 3 Version 2, but not
        in previous level/versions.  The latter is more succinct, but  might
        not be legal SBML for the desired target SBML document.

        This method lets you tell the parser which behavior to use---either
        parse '%' as the 'rem' function or as a piecewise function with the
        same interpretation.  The two possibilities are represented using the
        following constants:

        * L3P_MODULO_IS_REM (value = 'True):' use the 'rem' MathML
        function (AST_FUNCTION_REM).

        * L3P_MODULO_IS_PIECEWISE (value = 'False):' use  a piecewise
        function (AST_FUNCTION_PIECEWISE) to encode the modulo rule
        explicitly. Parameter 'modulol3v2' is a boolean value (one of the
        constants L3P_MODULO_IS_PIECEWISE or L3P_MODULO_IS_REM) indicating how
        the '%' symbol in the input should be handled.

        See also getParseModuloL3v2().

        """
        return _libsbml.L3ParserSettings_setParseModuloL3v2(self, modulol3v2)


    def getParseModuloL3v2(self):
        """
        getParseModuloL3v2(L3ParserSettings self) -> bool


        Indicates the current behavior set for handling the '%' sumbol in
        mathematical formulas.

        This setting affects whether the '%' symbol (modulo) is parsed as a
        piecewise equation that returns the modulo value of the entries on
        either side of the symbol, or whether it is parsed as the MathML
        'rem' function, which was allowed in SBML Level 3 Version 2, but not
        in previous level/versions.  The latter is more succinct, but  might
        not be legal SBML for the desired target SBML document.

        Returns A boolean indicating the behavior currently set.  The possible
        values are as follows:

        * L3P_MODULO_IS_REM (value = 'True):' use the 'rem' MathML function
        (AST_FUNCTION_REM).

        * L3P_MODULO_IS_PIECEWISE (value = 'False):' use  a piecewise
        function (AST_FUNCTION_PIECEWISE) to encode the modulo rule
        explicitly. See also setParseModuloL3v2().

        """
        return _libsbml.L3ParserSettings_getParseModuloL3v2(self)


    def setParseL3v2Functions(self, l3v2functions):
        """
        setParseL3v2Functions(L3ParserSettings self, bool l3v2functions)


        Sets the behavior for handling functions added in SBML L3v2

        This setting affects whether the names of functions added in SBML
        Level 3 Version 2 are parsed as those added MathML functions,  or
        whether they are added as generic functions with those names (to be
        used in SBML as function definitions).

        This method lets you tell the parser which behavior to use---either to
        parse the functions added in L3v2 as their built-in counterparts, or
        as generic functions with that name (to be defined by SBML as function
        definitions).  The two possibilities are represented using the
        following constants:

        * L3P_PARSE_L3V2_FUNCTIONS_DIRECTLY (value = 'True):' parse the
        strings 'rateOf', 'implies', 'max', 'min', 'quotient', and 'rem' as
        AST_FUNCTION_RATE_OF, AST_LOGICAL_IMPLIES, AST_FUNCTION_MAX,
        AST_FUNCTION_MIN, AST_FUNCTION_QUOTIENT, and AST_FUNCTION_REM,
        respectively.

        * L3P_PARSE_L3V2_FUNCTIONS_AS_GENERIC (value = 'False):'  parse the
        strings 'rateOf', 'implies', 'max', 'min', 'quotient', and  'rem' all
        as AST_FUNCTION with the appropriate name set. Parameter
        'l3v2functions' is a boolean value (one of the constants
        L3P_PARSE_L3V2_FUNCTIONS_DIRECTLY or
        L3P_PARSE_L3V2_FUNCTIONS_AS_GENERIC) indicating how to interpret those
        function names.

        See also getParseL3v2Functions().

        """
        return _libsbml.L3ParserSettings_setParseL3v2Functions(self, l3v2functions)


    def getParseL3v2Functions(self):
        """
        getParseL3v2Functions(L3ParserSettings self) -> bool


        Indicates the current behavior set for handling whether to parse the
        functions added in L3v2 as that MathML or not.

        This setting affects whether the names of functions added in SBML
        Level 3 Version 2 are parsed as those added MathML functions,  or
        whether they are added as generic functions with those names (to be
        used in SBML as function definitions).

        Returns A boolean indicating the behavior currently set.  The possible
        values are as follows:

        * L3P_PARSE_L3V2_FUNCTIONS_DIRECTLY (value = 'True):' parse the
        strings 'rateOf', 'implies', 'max', 'min', 'quotient', and 'rem' as
        AST_FUNCTION_RATE_OF, AST_LOGICAL_IMPLIES, AST_FUNCTION_MAX,
        AST_FUNCTION_MIN, AST_FUNCTION_QUOTIENT, and AST_FUNCTION_REM,
        respectively.

        * L3P_PARSE_L3V2_FUNCTIONS_AS_GENERIC (value = 'False):'  parse the
        strings 'rateOf', 'implies', 'max', 'min', 'quotient', and  'rem' all
        as AST_FUNCTION with the appropriate name set. See also
        setParsePackageMath().

        """
        return _libsbml.L3ParserSettings_getParseL3v2Functions(self)


    def setParsePackageMath(self, package, parsepackage):
        """
        setParsePackageMath(L3ParserSettings self, ExtendedMathType_t package, bool parsepackage)


        Sets the behavior for handling functions added in SBML packages

        This setting affects whether the math added in a given SBML Level 3
        package are parsed as those added MathML elements,  or whether they
        are added as generic functions or variables with those names.

        This method lets you tell the parser which behavior to use---either to
        parse the functions added in a given package as their built-in
        counterparts, or as generic functions with that name (to be defined by
        SBML as function definitions).  The two possibilities are represented
        using the following constants:

        * L3P_PARSE_PACKAGE_MATH_DIRECTLY (value = 'True):' parse any
        string defined in a given SBML L3 package as its corresponding
        ASTType_t.

        * L3P_PARSE_PACKAGE_MATH_AS_GENERIC (value = 'False):'  parse any
        string that would have been defined in the given SBML L3 package as
        AST_FUNCTION or AST_NAME  with the appropriate name set. Parameter
        'l3v2functions' is a boolean value (one of the constants
        L3P_PARSE_L3V2_FUNCTIONS_DIRECTLY or
        L3P_PARSE_L3V2_FUNCTIONS_AS_GENERIC) indicating how to interpret those
        function names.

        See also getParsePackageMath().

        """
        return _libsbml.L3ParserSettings_setParsePackageMath(self, package, parsepackage)


    def getParsePackageMath(self, package):
        """
        getParsePackageMath(L3ParserSettings self, ExtendedMathType_t package) -> bool


        Indicates the current behavior set for handling whether to parse the
        functions added in the given package as that MathML or not.

        This setting affects whether the math added in a given SBML Level 3
        package are parsed as those added MathML elements,  or whether they
        are added as generic functions or variables with those names.

        Returns A boolean indicating the behavior currently set.  The possible
        values are as follows:

        * L3P_PARSE_PACKAGE_MATH_DIRECTLY (value = 'True):' parse any  string
        defined in a given SBML L3 package as its corresponding ASTType_t.

        * L3P_PARSE_PACKAGE_MATH_AS_GENERIC (value = 'False):'  parse any
        string that would have been defined in the given SBML L3 package as
        AST_FUNCTION or AST_NAME  with the appropriate name set. See also
        setParsePackageMath().

        """
        return _libsbml.L3ParserSettings_getParsePackageMath(self, package)


    def visitPackageInfixSyntax(self, parent, node, sb):
        """
        visitPackageInfixSyntax(L3ParserSettings self, ASTNode parent, ASTNode node, StringBuffer_t * sb)


        Internal implementation method.

        """
        return _libsbml.L3ParserSettings_visitPackageInfixSyntax(self, parent, node, sb)

L3ParserSettings_swigregister = _libsbml.L3ParserSettings_swigregister
L3ParserSettings_swigregister(L3ParserSettings)

class DefinitionURLRegistry(_object):
    """

    Registry of all libSBML SBML DefinitionURLs.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  It is a class used in the
    implementation of extra functionality provided by libSBML.

    LibSBML provides facilities for transforming and converting SBML
    documents in various ways.  These transformations can involve
    essentially anything that can be written algorithmically; examples
    include converting the units of measurement in a model, or converting
    from one Level+Version combination of SBML to another.  DefinitionURLs
    are implemented as objects derived from the class DefinitionURL.

    The DefinitionURL registry, implemented as a singleton object of class
    DefinitionURLRegistry, maintains a list of known DefinitionURLs and
    provides methods for discovering them.  Callers can use the method
    DefinitionURLRegistry.getNumDefinitionURLs() to find out how many
    DefinitionURLs are registered, then use
    DefinitionURLRegistry.getDefinitionURLByIndex() to iterate over each
    one; alternatively, callers can use
    DefinitionURLRegistry.getDefinitionURLFor() to search for a
    DefinitionURL having specific properties.

    """

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DefinitionURLRegistry, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DefinitionURLRegistry, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def getInstance():
        """
        getInstance() -> DefinitionURLRegistry


        Returns the singleton instance for the DefinitionURL registry.

        Prior to using the registry, callers have to obtain a copy of the
        registry.  This static method provides the means for doing that.

        Returns the singleton for the DefinitionURL registry.

        """
        return _libsbml.DefinitionURLRegistry_getInstance()

    getInstance = staticmethod(getInstance)

    def addDefinitionURL(url, type):
        """
        addDefinitionURL(string url, int type) -> int


        Adds the given DefinitionURL to the registry of SBML DefinitionURLs.

        Parameter 'DefinitionURL' is the DefinitionURL to add to the registry.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_OBJECT

        """
        return _libsbml.DefinitionURLRegistry_addDefinitionURL(url, type)

    addDefinitionURL = staticmethod(addDefinitionURL)

    def getNumDefinitionURLs():
        """
        getNumDefinitionURLs() -> int


        Returns the number of DefinitionURLs known by the registry.

        Returns the number of registered DefinitionURLs.

        See also getDefinitionURLByIndex().

        """
        return _libsbml.DefinitionURLRegistry_getNumDefinitionURLs()

    getNumDefinitionURLs = staticmethod(getNumDefinitionURLs)

    def addSBMLDefinitions():
        """
        addSBMLDefinitions()




        """
        return _libsbml.DefinitionURLRegistry_addSBMLDefinitions()

    addSBMLDefinitions = staticmethod(addSBMLDefinitions)
    __swig_destroy__ = _libsbml.delete_DefinitionURLRegistry
    __del__ = lambda self: None

    def getCoreDefinitionsAdded():
        """
        getCoreDefinitionsAdded() -> bool




        """
        return _libsbml.DefinitionURLRegistry_getCoreDefinitionsAdded()

    getCoreDefinitionsAdded = staticmethod(getCoreDefinitionsAdded)

    def getType(url):
        """
        getType(string url) -> int




        """
        return _libsbml.DefinitionURLRegistry_getType(url)

    getType = staticmethod(getType)

    def getDefinitionUrlByIndex(index):
        """
        getDefinitionUrlByIndex(int index) -> string




        """
        return _libsbml.DefinitionURLRegistry_getDefinitionUrlByIndex(index)

    getDefinitionUrlByIndex = staticmethod(getDefinitionUrlByIndex)

    def clearDefinitions():
        """
        clearDefinitions()




        """
        return _libsbml.DefinitionURLRegistry_clearDefinitions()

    clearDefinitions = staticmethod(clearDefinitions)
DefinitionURLRegistry_swigregister = _libsbml.DefinitionURLRegistry_swigregister
DefinitionURLRegistry_swigregister(DefinitionURLRegistry)

def DefinitionURLRegistry_getInstance():
    """
    DefinitionURLRegistry_getInstance() -> DefinitionURLRegistry


    Returns the singleton instance for the DefinitionURL registry.

    Prior to using the registry, callers have to obtain a copy of the
    registry.  This static method provides the means for doing that.

    Returns the singleton for the DefinitionURL registry.

    """
    return _libsbml.DefinitionURLRegistry_getInstance()

def DefinitionURLRegistry_addDefinitionURL(url, type):
    """
    DefinitionURLRegistry_addDefinitionURL(string url, int type) -> int


    Adds the given DefinitionURL to the registry of SBML DefinitionURLs.

    Parameter 'DefinitionURL' is the DefinitionURL to add to the registry.

    Returns integer value indicating success/failure of the function.
    The possible values returned by this function are:

    * LIBSBML_OPERATION_SUCCESS

    * LIBSBML_INVALID_OBJECT

    """
    return _libsbml.DefinitionURLRegistry_addDefinitionURL(url, type)

def DefinitionURLRegistry_getNumDefinitionURLs():
    """
    DefinitionURLRegistry_getNumDefinitionURLs() -> int


    Returns the number of DefinitionURLs known by the registry.

    Returns the number of registered DefinitionURLs.

    See also getDefinitionURLByIndex().

    """
    return _libsbml.DefinitionURLRegistry_getNumDefinitionURLs()

def DefinitionURLRegistry_addSBMLDefinitions():
    """
    DefinitionURLRegistry_addSBMLDefinitions()




    """
    return _libsbml.DefinitionURLRegistry_addSBMLDefinitions()

def DefinitionURLRegistry_getCoreDefinitionsAdded():
    """
    DefinitionURLRegistry_getCoreDefinitionsAdded() -> bool




    """
    return _libsbml.DefinitionURLRegistry_getCoreDefinitionsAdded()

def DefinitionURLRegistry_getType(url):
    """
    DefinitionURLRegistry_getType(string url) -> int




    """
    return _libsbml.DefinitionURLRegistry_getType(url)

def DefinitionURLRegistry_getDefinitionUrlByIndex(index):
    """
    DefinitionURLRegistry_getDefinitionUrlByIndex(int index) -> string




    """
    return _libsbml.DefinitionURLRegistry_getDefinitionUrlByIndex(index)

def DefinitionURLRegistry_clearDefinitions():
    """
    DefinitionURLRegistry_clearDefinitions()




    """
    return _libsbml.DefinitionURLRegistry_clearDefinitions()

class ASTNodeValues_t(_object):
    """Proxy of C++ ASTNodeValues_t class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ASTNodeValues_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ASTNodeValues_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["name"] = _libsbml.ASTNodeValues_t_name_set
    __swig_getmethods__["name"] = _libsbml.ASTNodeValues_t_name_get
    if _newclass:
        name = _swig_property(_libsbml.ASTNodeValues_t_name_get, _libsbml.ASTNodeValues_t_name_set)
    __swig_setmethods__["type"] = _libsbml.ASTNodeValues_t_type_set
    __swig_getmethods__["type"] = _libsbml.ASTNodeValues_t_type_get
    if _newclass:
        type = _swig_property(_libsbml.ASTNodeValues_t_type_get, _libsbml.ASTNodeValues_t_type_set)
    __swig_setmethods__["isFunction"] = _libsbml.ASTNodeValues_t_isFunction_set
    __swig_getmethods__["isFunction"] = _libsbml.ASTNodeValues_t_isFunction_get
    if _newclass:
        isFunction = _swig_property(_libsbml.ASTNodeValues_t_isFunction_get, _libsbml.ASTNodeValues_t_isFunction_set)
    __swig_setmethods__["csymbolURL"] = _libsbml.ASTNodeValues_t_csymbolURL_set
    __swig_getmethods__["csymbolURL"] = _libsbml.ASTNodeValues_t_csymbolURL_get
    if _newclass:
        csymbolURL = _swig_property(_libsbml.ASTNodeValues_t_csymbolURL_get, _libsbml.ASTNodeValues_t_csymbolURL_set)
    __swig_setmethods__["allowedChildrenType"] = _libsbml.ASTNodeValues_t_allowedChildrenType_set
    __swig_getmethods__["allowedChildrenType"] = _libsbml.ASTNodeValues_t_allowedChildrenType_get
    if _newclass:
        allowedChildrenType = _swig_property(_libsbml.ASTNodeValues_t_allowedChildrenType_get, _libsbml.ASTNodeValues_t_allowedChildrenType_set)
    __swig_setmethods__["numAllowedChildren"] = _libsbml.ASTNodeValues_t_numAllowedChildren_set
    __swig_getmethods__["numAllowedChildren"] = _libsbml.ASTNodeValues_t_numAllowedChildren_get
    if _newclass:
        numAllowedChildren = _swig_property(_libsbml.ASTNodeValues_t_numAllowedChildren_get, _libsbml.ASTNodeValues_t_numAllowedChildren_set)

    def __init__(self):
        """__init__(ASTNodeValues_t self) -> ASTNodeValues_t"""
        this = _libsbml.new_ASTNodeValues_t()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_ASTNodeValues_t
    __del__ = lambda self: None
ASTNodeValues_t_swigregister = _libsbml.ASTNodeValues_t_swigregister
ASTNodeValues_t_swigregister(ASTNodeValues_t)

class ASTBasePlugin(_object):
    """

    Internal implementation method.

    """

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ASTBasePlugin, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ASTBasePlugin, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def getStringFor(self, type):
        """getStringFor(ASTBasePlugin self, ASTNodeType_t type) -> string"""
        return _libsbml.ASTBasePlugin_getStringFor(self, type)


    def getConstCharFor(self, type):
        """getConstCharFor(ASTBasePlugin self, ASTNodeType_t type) -> char const *"""
        return _libsbml.ASTBasePlugin_getConstCharFor(self, type)


    def getConstCharCsymbolURLFor(self, type):
        """getConstCharCsymbolURLFor(ASTBasePlugin self, ASTNodeType_t type) -> char const *"""
        return _libsbml.ASTBasePlugin_getConstCharCsymbolURLFor(self, type)


    def getASTNodeTypeFor(self, symbol):
        """getASTNodeTypeFor(ASTBasePlugin self, string symbol) -> ASTNodeType_t"""
        return _libsbml.ASTBasePlugin_getASTNodeTypeFor(self, symbol)


    def getASTNodeTypeForCSymbolURL(self, url):
        """getASTNodeTypeForCSymbolURL(ASTBasePlugin self, string url) -> ASTNodeType_t"""
        return _libsbml.ASTBasePlugin_getASTNodeTypeForCSymbolURL(self, url)


    def hasCorrectNamespace(self, namespaces):
        """hasCorrectNamespace(ASTBasePlugin self, SBMLNamespaces namespaces) -> bool"""
        return _libsbml.ASTBasePlugin_hasCorrectNamespace(self, namespaces)


    def defines(self, *args):
        """
        defines(ASTBasePlugin self, ASTNodeType_t type) -> bool
        defines(ASTBasePlugin self, string name, bool strCmpIsCaseSensitive=False) -> bool
        defines(ASTBasePlugin self, string name) -> bool
        """
        return _libsbml.ASTBasePlugin_defines(self, *args)


    def isFunction(self, type):
        """isFunction(ASTBasePlugin self, ASTNodeType_t type) -> bool"""
        return _libsbml.ASTBasePlugin_isFunction(self, type)


    def isLogical(self, type):
        """isLogical(ASTBasePlugin self, ASTNodeType_t type) -> bool"""
        return _libsbml.ASTBasePlugin_isLogical(self, type)


    def isMathMLNodeTag(self, *args):
        """
        isMathMLNodeTag(ASTBasePlugin self, string node) -> bool
        isMathMLNodeTag(ASTBasePlugin self, ASTNodeType_t type) -> bool
        """
        return _libsbml.ASTBasePlugin_isMathMLNodeTag(self, *args)


    def getExtendedMathType(self):
        """getExtendedMathType(ASTBasePlugin self) -> ExtendedMathType_t"""
        return _libsbml.ASTBasePlugin_getExtendedMathType(self)


    def evaluateASTNode(self, node, m=None):
        """
        evaluateASTNode(ASTBasePlugin self, ASTNode node, Model m=None) -> double
        evaluateASTNode(ASTBasePlugin self, ASTNode node) -> double
        """
        return _libsbml.ASTBasePlugin_evaluateASTNode(self, node, m)


    def getUnitDefinitionFromPackage(self, uff, node, inKL, reactNo):
        """getUnitDefinitionFromPackage(ASTBasePlugin self, UnitFormulaFormatter * uff, ASTNode node, bool inKL, int reactNo) -> UnitDefinition"""
        return _libsbml.ASTBasePlugin_getUnitDefinitionFromPackage(self, uff, node, inKL, reactNo)


    def getASTNodeValue(self, n):
        """getASTNodeValue(ASTBasePlugin self, unsigned int n) -> ASTNodeValues_t"""
        return _libsbml.ASTBasePlugin_getASTNodeValue(self, n)


    def allowedInFunctionDefinition(self, type):
        """
        allowedInFunctionDefinition(ASTBasePlugin self, ASTNodeType_t type) -> int


        Internal implementation method.

        """
        return _libsbml.ASTBasePlugin_allowedInFunctionDefinition(self, type)

    __swig_destroy__ = _libsbml.delete_ASTBasePlugin
    __del__ = lambda self: None

    def clone(self):
        """
        clone(ASTBasePlugin self) -> ASTBasePlugin


        Internal implementation method.

        """
        return _libsbml.ASTBasePlugin_clone(self)


    def getElementNamespace(self):
        """
        getElementNamespace(ASTBasePlugin self) -> string


        Internal implementation method.

        """
        return _libsbml.ASTBasePlugin_getElementNamespace(self)


    def getPrefix(self):
        """
        getPrefix(ASTBasePlugin self) -> string


        Internal implementation method.

        """
        return _libsbml.ASTBasePlugin_getPrefix(self)


    def getPackageName(self):
        """
        getPackageName(ASTBasePlugin self) -> string


        Internal implementation method.

        """
        return _libsbml.ASTBasePlugin_getPackageName(self)


    def setSBMLExtension(self, ext):
        """
        setSBMLExtension(ASTBasePlugin self, SBMLExtension ext) -> int


        Internal implementation method.

        """
        return _libsbml.ASTBasePlugin_setSBMLExtension(self, ext)


    def setPrefix(self, prefix):
        """
        setPrefix(ASTBasePlugin self, string prefix) -> int


        Internal implementation method.

        """
        return _libsbml.ASTBasePlugin_setPrefix(self, prefix)


    def connectToParent(self, astbase):
        """
        connectToParent(ASTBasePlugin self, ASTNode astbase)


        Internal implementation method.

        """
        return _libsbml.ASTBasePlugin_connectToParent(self, astbase)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(ASTBasePlugin self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.ASTBasePlugin_enablePackageInternal(self, pkgURI, pkgPrefix, flag)


    def stripPackage(self, pkgPrefix, flag):
        """
        stripPackage(ASTBasePlugin self, string pkgPrefix, bool flag) -> bool


        Internal implementation method.

        """
        return _libsbml.ASTBasePlugin_stripPackage(self, pkgPrefix, flag)


    def getURI(self):
        """
        getURI(ASTBasePlugin self) -> string


        Internal implementation method.

        """
        return _libsbml.ASTBasePlugin_getURI(self)


    def getParentASTObject(self, *args):
        """
        getParentASTObject(ASTBasePlugin self) -> ASTNode
        getParentASTObject(ASTBasePlugin self) -> ASTNode


        Internal implementation method.

        """
        return _libsbml.ASTBasePlugin_getParentASTObject(self, *args)


    def setElementNamespace(self, uri):
        """
        setElementNamespace(ASTBasePlugin self, string uri) -> int


        Internal implementation method.

        """
        return _libsbml.ASTBasePlugin_setElementNamespace(self, uri)


    def getLevel(self):
        """
        getLevel(ASTBasePlugin self) -> unsigned int


        Internal implementation method.

        """
        return _libsbml.ASTBasePlugin_getLevel(self)


    def getVersion(self):
        """
        getVersion(ASTBasePlugin self) -> unsigned int


        Internal implementation method.

        """
        return _libsbml.ASTBasePlugin_getVersion(self)


    def getPackageVersion(self):
        """
        getPackageVersion(ASTBasePlugin self) -> unsigned int


        Internal implementation method.

        """
        return _libsbml.ASTBasePlugin_getPackageVersion(self)


    def getSBMLNamespaces(self):
        """
        getSBMLNamespaces(ASTBasePlugin self) -> SBMLNamespaces


        Internal implementation method.

        """
        return _libsbml.ASTBasePlugin_getSBMLNamespaces(self)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(ASTBasePlugin self, string oldid, string newid)


        Internal implementation method.

        """
        return _libsbml.ASTBasePlugin_renameSIdRefs(self, oldid, newid)


    def renameUnitSIdRefs(self, oldid, newid):
        """
        renameUnitSIdRefs(ASTBasePlugin self, string oldid, string newid)


        Internal implementation method.

        """
        return _libsbml.ASTBasePlugin_renameUnitSIdRefs(self, oldid, newid)


    def replaceIDWithFunction(self, id, function):
        """
        replaceIDWithFunction(ASTBasePlugin self, string id, ASTNode function)


        Internal implementation method.

        """
        return _libsbml.ASTBasePlugin_replaceIDWithFunction(self, id, function)


    def checkNumArguments(self, function, error):
        """
        checkNumArguments(ASTBasePlugin self, ASTNode function, std::stringstream & error) -> int


        Internal implementation method.

        """
        return _libsbml.ASTBasePlugin_checkNumArguments(self, function, error)


    def getL3PackageInfixPrecedence(self):
        """
        getL3PackageInfixPrecedence(ASTBasePlugin self) -> int


        Internal implementation method.

        """
        return _libsbml.ASTBasePlugin_getL3PackageInfixPrecedence(self)


    def hasCorrectNumArguments(self, function):
        """
        hasCorrectNumArguments(ASTBasePlugin self, ASTNode function) -> bool


        Internal implementation method.

        """
        return _libsbml.ASTBasePlugin_hasCorrectNumArguments(self, function)


    def hasPackageOnlyInfixSyntax(self):
        """
        hasPackageOnlyInfixSyntax(ASTBasePlugin self) -> bool


        Internal implementation method.

        """
        return _libsbml.ASTBasePlugin_hasPackageOnlyInfixSyntax(self)


    def hasUnambiguousPackageInfixGrammar(self, child):
        """
        hasUnambiguousPackageInfixGrammar(ASTBasePlugin self, ASTNode child) -> bool


        Internal implementation method.

        """
        return _libsbml.ASTBasePlugin_hasUnambiguousPackageInfixGrammar(self, child)


    def isPackageInfixFunction(self):
        """
        isPackageInfixFunction(ASTBasePlugin self) -> bool


        Internal implementation method.

        """
        return _libsbml.ASTBasePlugin_isPackageInfixFunction(self)

ASTBasePlugin_swigregister = _libsbml.ASTBasePlugin_swigregister
ASTBasePlugin_swigregister(ASTBasePlugin)

class CompExtension(SBMLExtension):
    """

    [SBML 'comp' package]  Base extension class for the package.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    """

    __swig_setmethods__ = {}
    for _s in [SBMLExtension]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CompExtension, name, value)
    __swig_getmethods__ = {}
    for _s in [SBMLExtension]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CompExtension, name)
    __repr__ = _swig_repr

    def getPackageName():
        """
        getPackageName() -> string


        Returns the nickname of the SBML Level 3 package implemented by this
        libSBML extension.

        Returns the package nickname, as a string.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.CompExtension_getPackageName()

    getPackageName = staticmethod(getPackageName)

    def getDefaultLevel():
        """
        getDefaultLevel() -> unsigned int


        Returns the default SBML Level used by this libSBML package extension.

        Returns the SBML Level.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.CompExtension_getDefaultLevel()

    getDefaultLevel = staticmethod(getDefaultLevel)

    def getDefaultVersion():
        """
        getDefaultVersion() -> unsigned int


        Returns the default SBML Version used by this libSBML package
        extension.

        Returns the Version within the default SBML Level.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.CompExtension_getDefaultVersion()

    getDefaultVersion = staticmethod(getDefaultVersion)

    def getDefaultPackageVersion():
        """
        getDefaultPackageVersion() -> unsigned int


        Returns the default version of the SBML Level 3 package implemented by
        this libSBML extension.

        Returns the default version number of the SBML Level 3 package
        definition.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.CompExtension_getDefaultPackageVersion()

    getDefaultPackageVersion = staticmethod(getDefaultPackageVersion)

    def getXmlnsL3V1V1():
        """
        getXmlnsL3V1V1() -> string


        Returns the XML namespace URI of the SBML Level 3 package implemented
        by this libSBML extension.

        Returns the XML namespace as a string.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.CompExtension_getXmlnsL3V1V1()

    getXmlnsL3V1V1 = staticmethod(getXmlnsL3V1V1)

    def __init__(self, *args):
        """
        __init__(CompExtension self) -> CompExtension
        __init__(CompExtension self, CompExtension source) -> CompExtension


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            CompExtension(CompExtension source)

        Copy constructor.

        Parameter 'source' is the instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            CompExtension()

        Creates a new CompExtension instance.

        """
        this = _libsbml.new_CompExtension(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_CompExtension
    __del__ = lambda self: None

    def clone(self):
        """
        clone(CompExtension self) -> CompExtension


        Creates and returns a deep copy of this CompExtension object.

        Returns a (deep) copy of this CompExtension object.

        """
        return _libsbml.CompExtension_clone(self)


    def getName(self):
        """
        getName(CompExtension self) -> string


        Returns the name of this package as a short-form label ("comp").

        Returns the name of this package.

        """
        return _libsbml.CompExtension_getName(self)


    def getURI(self, sbmlLevel, sbmlVersion, pkgVersion):
        """
        getURI(CompExtension self, unsigned int sbmlLevel, unsigned int sbmlVersion, unsigned int pkgVersion) -> string


        Returns a string representing the SBML XML namespace of this SBML
        Level 3 package.

        The namespace URI constructed by this method corresponds to the
        combination of the Level and Version of SBML, and the Version of the
        SBML Level 3 package. (At the time of this writing, the only SBML
        Level that supports packages is Level 3, so the value of 'sbmlLevel'
        must necessarily always be 3.)

        Parameter 'sbmlLevel' is the level of SBML. Parameter 'sbmlVersion' is
        the version of SBML. Parameter 'pkgVersion' is the version of the
        package.

        Returns a string of the package URI, or an empty string if no
        corresponding URI exists.

        """
        return _libsbml.CompExtension_getURI(self, sbmlLevel, sbmlVersion, pkgVersion)


    def getLevel(self, uri):
        """
        getLevel(CompExtension self, string uri) -> unsigned int


        Returns the SBML Level for the given URI of this package.

        Parameter 'uri' is a URI that represents a version of this package.

        Returns the SBML Level for the given URI of this package, or '0' if
        the given URI is invalid, or for a different package.

        """
        return _libsbml.CompExtension_getLevel(self, uri)


    def getVersion(self, uri):
        """
        getVersion(CompExtension self, string uri) -> unsigned int


        Returns the Version within the SBML Level for the given URI of this
        package.

        Parameter 'uri' is a URI that represents a version of this package.

        Returns the SBML Version within the SBML Level for the given URI of
        this package, or '0' if the given URI is invalid, or for a different
        package.

        """
        return _libsbml.CompExtension_getVersion(self, uri)


    def getPackageVersion(self, uri):
        """
        getPackageVersion(CompExtension self, string uri) -> unsigned int


        Returns the SBML Level 3 package version for the given URI of this
        package.

        Parameter 'uri' is a URI that represents one of the valid versions of
        this package.

        Returns the version of the SBML Level 3 package with the given URI, or
        '0' if the given URI is invalid, or for a different package.

        """
        return _libsbml.CompExtension_getPackageVersion(self, uri)


    def getSBMLExtensionNamespaces(self, uri):
        """
        getSBMLExtensionNamespaces(CompExtension self, string uri) -> SBMLNamespaces


        Returns a CompPkgNamespaces object.

        Parameter 'uri' is a URI that represents one of the valid versions of
        the "comp" package.

        Returns an CompPkgNamespaces object corresponding to the given 'uri',
        or 'None' if the URI is not defined in the Hierarchical Model
        Composition package.

        """
        return _libsbml.CompExtension_getSBMLExtensionNamespaces(self, uri)


    def getStringFromTypeCode(self, typeCode):
        """
        getStringFromTypeCode(CompExtension self, int typeCode) -> char const *


        Takes a type code of the "comp" package and returns a string
        describing the code.

        Parameter 'typeCode' is a libSBML type code defined by the libSBML
        extension implementing support for the SBML Level 3 "comp" package.

        Returns a text string representing the type code given by 'typeCode'.
        If the type code is unrecognized for this implementation of the
        libSBML "comp" package, the string returned will be '(Unknown SBML
        Comp Type)'.

        """
        return _libsbml.CompExtension_getStringFromTypeCode(self, typeCode)


    def init():
        """
        init()


        Internal implementation method.

        """
        return _libsbml.CompExtension_init()

    init = staticmethod(init)

    def getErrorTable(self, index):
        """
        getErrorTable(CompExtension self, unsigned int index) -> packageErrorTableEntry


        Internal implementation method.

        """
        return _libsbml.CompExtension_getErrorTable(self, index)


    def getErrorTableIndex(self, errorId):
        """
        getErrorTableIndex(CompExtension self, unsigned int errorId) -> unsigned int


        Internal implementation method.

        """
        return _libsbml.CompExtension_getErrorTableIndex(self, errorId)


    def getErrorIdOffset(self):
        """
        getErrorIdOffset(CompExtension self) -> unsigned int


        Internal implementation method.

        """
        return _libsbml.CompExtension_getErrorIdOffset(self)

CompExtension_swigregister = _libsbml.CompExtension_swigregister
CompExtension_swigregister(CompExtension)

def CompExtension_getPackageName():
    """
    CompExtension_getPackageName() -> string


    Returns the nickname of the SBML Level 3 package implemented by this
    libSBML extension.

    Returns the package nickname, as a string.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.CompExtension_getPackageName()

def CompExtension_getDefaultLevel():
    """
    CompExtension_getDefaultLevel() -> unsigned int


    Returns the default SBML Level used by this libSBML package extension.

    Returns the SBML Level.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.CompExtension_getDefaultLevel()

def CompExtension_getDefaultVersion():
    """
    CompExtension_getDefaultVersion() -> unsigned int


    Returns the default SBML Version used by this libSBML package
    extension.

    Returns the Version within the default SBML Level.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.CompExtension_getDefaultVersion()

def CompExtension_getDefaultPackageVersion():
    """
    CompExtension_getDefaultPackageVersion() -> unsigned int


    Returns the default version of the SBML Level 3 package implemented by
    this libSBML extension.

    Returns the default version number of the SBML Level 3 package
    definition.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.CompExtension_getDefaultPackageVersion()

def CompExtension_getXmlnsL3V1V1():
    """
    CompExtension_getXmlnsL3V1V1() -> string


    Returns the XML namespace URI of the SBML Level 3 package implemented
    by this libSBML extension.

    Returns the XML namespace as a string.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.CompExtension_getXmlnsL3V1V1()

def CompExtension_init():
    """
    CompExtension_init()


    Internal implementation method.

    """
    return _libsbml.CompExtension_init()

SBML_COMP_SUBMODEL = _libsbml.SBML_COMP_SUBMODEL
SBML_COMP_MODELDEFINITION = _libsbml.SBML_COMP_MODELDEFINITION
SBML_COMP_EXTERNALMODELDEFINITION = _libsbml.SBML_COMP_EXTERNALMODELDEFINITION
SBML_COMP_SBASEREF = _libsbml.SBML_COMP_SBASEREF
SBML_COMP_DELETION = _libsbml.SBML_COMP_DELETION
SBML_COMP_REPLACEDELEMENT = _libsbml.SBML_COMP_REPLACEDELEMENT
SBML_COMP_REPLACEDBY = _libsbml.SBML_COMP_REPLACEDBY
SBML_COMP_PORT = _libsbml.SBML_COMP_PORT
class CompSBasePlugin(SBasePlugin):
    """

    [SBML 'comp' package]  Extension of SBase.

    The CompSBasePlugin class inherits from the SBasePlugin class, and
    codifies the extensions to the SBase class defined in the Hierarchical
    Model Composition ("comp") package.  This extension allows the
    modeler to define one or more submodel elements which the parent SBase
    object replaces, and/or a single submodel element which replaces the
    parent SBase object. This is accomplished through the addition of an
    optional ListOfReplacedElements child, which may contain one or more
    ReplacedElement objects, each of which  references a submodel object
    to be replaced by the containing SBase object,  and through the
    addition of a single optional ReplacedBy child, which  references a
    submodel object which is to replace the containing SBase object. If a
    single SBase element both contains a ListOfReplacedElements and has a
    ReplacedBy child, it and all the referenced ReplacedElement objects
    are to be replaced by the object referenced by the ReplacedBy element.

    See also ReplacedElement, ReplacedBy.

    """

    __swig_setmethods__ = {}
    for _s in [SBasePlugin]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CompSBasePlugin, name, value)
    __swig_getmethods__ = {}
    for _s in [SBasePlugin]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CompSBasePlugin, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(CompSBasePlugin self, string uri, string prefix, CompPkgNamespaces compns) -> CompSBasePlugin
        __init__(CompSBasePlugin self, CompSBasePlugin orig) -> CompSBasePlugin


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            CompSBasePlugin(string &uri, string &prefix,
        CompPkgNamespaces compns)

        Creates a new CompSBasePlugin object using the given parameters.

        In the XML representation of an SBML document, XML namespaces are
        used to identify the origin of each XML construct used.  XML
        namespaces are identified by their unique resource identifiers (URIs).
        The core SBML specifications stipulate the namespaces that must be
        used for core SBML constructs; for example, all XML elements that
        belong to SBML Level 3 Version 1 Core must be placed in the XML
        namespace identified by the URI
        'http://www.sbml.org/sbml/level3/version1/core'.  Individual SBML
        Level 3 packages define their own XML namespaces; for example, all
        elements belonging to the SBML Level 3 Layout Version 1 package must
        be placed in the XML namespace
        'http://www.sbml.org/sbml/level3/version1/layout/version1/'.

        The SBMLNamespaces object encapsulates SBML Level/Version/namespaces
        information.  It is used to communicate the SBML Level, Version, and
        (in Level 3) packages used in addition to SBML Level 3 Core.  A common
        approach to using libSBML's SBMLNamespaces facilities is to create an
        SBMLNamespaces object somewhere in a program once, then hand that
        object as needed to object constructors that accept SBMLNamespaces as
        arguments.

        Parameter 'uri' is the URI of the SBML Level 3 package implemented by
        this libSBML package extension.

        Parameter 'prefix' is the XML namespace prefix being used for the
        package.

        Parameter 'compns' is the namespaces object for the package.

        ______________________________________________________________________
        Method variant with the following signature:

            CompSBasePlugin(CompSBasePlugin orig)

        Copy constructor. Creates a copy of this CompSBasePlugin object.

        Parameter 'orig' is the instance to copy.

        """
        this = _libsbml.new_CompSBasePlugin(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_CompSBasePlugin
    __del__ = lambda self: None

    def clone(self):
        """
        clone(CompSBasePlugin self) -> CompSBasePlugin


        Creates and returns a deep copy of this CompSBasePlugin object.

        Returns a (deep) copy of this CompSBasePlugin object.

        """
        return _libsbml.CompSBasePlugin_clone(self)


    def createObject(self, stream):
        """
        createObject(CompSBasePlugin self, XMLInputStream stream) -> SBase


        Internal implementation method.

        """
        return _libsbml.CompSBasePlugin_createObject(self, stream)


    def getElementBySId(self, id):
        """
        getElementBySId(CompSBasePlugin self, string id) -> SBase


        Returns the first child element found that has the given 'id' in the
        model-wide SId namespace, or 'None' if no such object is found.

        Parameter 'id' is string representing the id of the object to find.

        Returns a pointer to the SBase element with the given 'id'.

        """
        return _libsbml.CompSBasePlugin_getElementBySId(self, id)


    def getElementByMetaId(self, metaid):
        """
        getElementByMetaId(CompSBasePlugin self, string metaid) -> SBase


        Returns the first child element it can find with the given 'metaid',
        or itself if it has the given 'metaid', or 'None' if no such object is
        found.

        Parameter 'metaid' is string representing the metaid of the object to
        find.

        Returns a pointer to the SBase element with the given 'metaid'.

        """
        return _libsbml.CompSBasePlugin_getElementByMetaId(self, metaid)


    def getListOfReplacedElements(self, *args):
        """
        getListOfReplacedElements(CompSBasePlugin self) -> ListOfReplacedElements
        getListOfReplacedElements(CompSBasePlugin self) -> ListOfReplacedElements


        Returns the ListOf object that holds all replacedElements.

        Returns the ListOf object that holds all replacedElements.

        """
        return _libsbml.CompSBasePlugin_getListOfReplacedElements(self, *args)


    def getReplacedElement(self, *args):
        """
        getReplacedElement(CompSBasePlugin self, unsigned int n) -> ReplacedElement
        getReplacedElement(CompSBasePlugin self, unsigned int n) -> ReplacedElement


        Returns the ReplacedElement with the given index.

        Parameter 'n' is the index number of the ReplacedElement to get.

        Returns the nth ReplacedElement in the ListOfReplacedElements.  If the
        index is invalid, 'None' is returned.

        """
        return _libsbml.CompSBasePlugin_getReplacedElement(self, *args)


    def addReplacedElement(self, replacedElement):
        """
        addReplacedElement(CompSBasePlugin self, ReplacedElement replacedElement) -> int


        Adds a copy of the given ReplacedElement object to the list of
        ReplacedElements.

        Parameter 'replacedElement' is the ReplacedElement object to be added
        to the list of ReplacedElements.  Fails if the added ReplacedElement
        is 'None,' does not match the level/version/package of the parent
        object, or cannot be added to the list of replaced elements.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_PKG_VERSION_MISMATCH

        """
        return _libsbml.CompSBasePlugin_addReplacedElement(self, replacedElement)


    def getNumReplacedElements(self):
        """
        getNumReplacedElements(CompSBasePlugin self) -> unsigned int


        Returns the number of ReplacedElements for this CompSBasePlugin.

        Returns the number of ReplacedElements for this CompSBasePlugin.

        """
        return _libsbml.CompSBasePlugin_getNumReplacedElements(self)


    def clearReplacedElements(self):
        """
        clearReplacedElements(CompSBasePlugin self)


        Remove all ReplacedElements, if any exist.

        """
        return _libsbml.CompSBasePlugin_clearReplacedElements(self)


    def createReplacedElement(self):
        """
        createReplacedElement(CompSBasePlugin self) -> ReplacedElement


        Creates a ReplacedElement object, adds it to the end of the
        ReplacedElement objects list and returns a pointer to the newly
        created object.

        Returns a newly created ReplacedElement object.

        """
        return _libsbml.CompSBasePlugin_createReplacedElement(self)


    def removeReplacedElement(self, index):
        """
        removeReplacedElement(CompSBasePlugin self, unsigned int index) -> ReplacedElement


        Removes the ReplacedElement with the given index.

        A pointer to the ReplacedElement that was removed is returned. If no
        ReplacedElement has been removed, 'None' is returned.

        Parameter 'index' is the index of the ReplacedElement object to
        remove.

        Returns the ReplacedElement object removed.  As mentioned above,  the
        caller owns the returned object. 'None' is returned if  the given
        index is out of range.

        """
        return _libsbml.CompSBasePlugin_removeReplacedElement(self, index)


    def getReplacedBy(self, *args):
        """
        getReplacedBy(CompSBasePlugin self) -> ReplacedBy
        getReplacedBy(CompSBasePlugin self) -> ReplacedBy


        Get the child ReplacedBy of this SBase.

        Returns the  ReplacedBy child of this SBase.

        """
        return _libsbml.CompSBasePlugin_getReplacedBy(self, *args)


    def isSetReplacedBy(self):
        """
        isSetReplacedBy(CompSBasePlugin self) -> bool


        Predicate for testing whether the ReplacedBy for this SBase is set.

        Returns 'True' if the ReplacedBy of this SBase is set, 'False'
        otherwise.

        """
        return _libsbml.CompSBasePlugin_isSetReplacedBy(self)


    def setReplacedBy(self, replacedBy):
        """
        setReplacedBy(CompSBasePlugin self, ReplacedBy replacedBy) -> int


        Sets the ReplacedBy definition of this SBase to a copy of the given
        ReplacedBy object instance.

        This method fails if the added ReplacedBy does not match the
        level/version/package of the parent object or if the added ReplacedBy
        cannot be copied.

        Parameter 'replacedBy' is the ReplacedBy object instance to use.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_PKG_VERSION_MISMATCH

        """
        return _libsbml.CompSBasePlugin_setReplacedBy(self, replacedBy)


    def createReplacedBy(self):
        """
        createReplacedBy(CompSBasePlugin self) -> ReplacedBy


        Creates a new, empty ReplacedBy, adds it to this CompSBasePlugin and
        returns the created ReplacedBy.

        Returns the newly created ReplacedBy object instance.

        """
        return _libsbml.CompSBasePlugin_createReplacedBy(self)


    def unsetReplacedBy(self):
        """
        unsetReplacedBy(CompSBasePlugin self) -> int


        Unsets the child ReplacedBy of this SBase.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.CompSBasePlugin_unsetReplacedBy(self)


    def logInvalidId(self, attribute, wrongattribute):
        """
        logInvalidId(CompSBasePlugin self, string attribute, string wrongattribute)


        Helper to log a common type of error.

        """
        return _libsbml.CompSBasePlugin_logInvalidId(self, attribute, wrongattribute)


    def connectToChild(self):
        """
        connectToChild(CompSBasePlugin self)


        Internal implementation method.

        """
        return _libsbml.CompSBasePlugin_connectToChild(self)


    def connectToParent(self, parent):
        """
        connectToParent(CompSBasePlugin self, SBase parent)


        Internal implementation method.

        """
        return _libsbml.CompSBasePlugin_connectToParent(self, parent)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(CompSBasePlugin self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.CompSBasePlugin_enablePackageInternal(self, pkgURI, pkgPrefix, flag)

CompSBasePlugin_swigregister = _libsbml.CompSBasePlugin_swigregister
CompSBasePlugin_swigregister(CompSBasePlugin)

class CompModelPlugin(CompSBasePlugin):
    """

    [SBML 'comp' package]  Extension of Model.

    The CompModelPlugin class inherits from the SBMLSBasePlugin class, and
    codifies the extensions to the Model class defined in the SBML Level 3
    Hierarchical Model Composition ("comp") package.  This extension
    allows a Model to define Submodels (other Models that are instantiated
    as new parts of the parent Model), and Ports, a defined interface for
    including the given Model as a Submodel of a different Model.

    Submodels are stored in an optional child ListOfSubmodels object,
    which,  if present, must contain one or more Submodel objects.  All of
    the Submodels present in the ListOfSubmodels are defined to be
    instantiated in the 'complete' Model.

    Ports are stored in an optional child ListOfPorts object, which,  if
    present, must contain one or more Port objects.  All of the Ports
    present in the ListOfPorts collectively define the 'port interface' of
    the Model.

    """

    __swig_setmethods__ = {}
    for _s in [CompSBasePlugin]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CompModelPlugin, name, value)
    __swig_getmethods__ = {}
    for _s in [CompSBasePlugin]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CompModelPlugin, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(CompModelPlugin self, string uri, string prefix, CompPkgNamespaces compns) -> CompModelPlugin
        __init__(CompModelPlugin self, CompModelPlugin orig) -> CompModelPlugin


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            CompModelPlugin(string &uri, string &prefix,
        CompPkgNamespaces compns)

        Creates a new CompModelPlugin object using the given parameters.

        In the XML representation of an SBML document, XML namespaces are
        used to identify the origin of each XML construct used.  XML
        namespaces are identified by their unique resource identifiers (URIs).
        The core SBML specifications stipulate the namespaces that must be
        used for core SBML constructs; for example, all XML elements that
        belong to SBML Level 3 Version 1 Core must be placed in the XML
        namespace identified by the URI
        'http://www.sbml.org/sbml/level3/version1/core'.  Individual SBML
        Level 3 packages define their own XML namespaces; for example, all
        elements belonging to the SBML Level 3 Layout Version 1 package must
        be placed in the XML namespace
        'http://www.sbml.org/sbml/level3/version1/layout/version1/'.

        The SBMLNamespaces object encapsulates SBML Level/Version/namespaces
        information.  It is used to communicate the SBML Level, Version, and
        (in Level 3) packages used in addition to SBML Level 3 Core.  A common
        approach to using libSBML's SBMLNamespaces facilities is to create an
        SBMLNamespaces object somewhere in a program once, then hand that
        object as needed to object constructors that accept SBMLNamespaces as
        arguments.

        Parameter 'uri' is the URI of the SBML Level 3 package implemented by
        this libSBML package extension.

        Parameter 'prefix' is the XML namespace prefix being used for the
        package.

        Parameter 'compns' is the namespaces object for the package.

        ______________________________________________________________________
        Method variant with the following signature:

            CompModelPlugin(CompModelPlugin orig)

        Copy constructor. Creates a copy of this CompModelPlugin object.

        Parameter 'orig' is the instance to copy.

        """
        this = _libsbml.new_CompModelPlugin(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_CompModelPlugin
    __del__ = lambda self: None

    def clone(self):
        """
        clone(CompModelPlugin self) -> CompModelPlugin


        Creates and returns a deep copy of this CompModelPlugin object.

        Returns a (deep) copy of this CompModelPlugin object.

        """
        return _libsbml.CompModelPlugin_clone(self)


    def createObject(self, stream):
        """
        createObject(CompModelPlugin self, XMLInputStream stream) -> SBase


        Internal implementation method.

        """
        return _libsbml.CompModelPlugin_createObject(self, stream)


    def getElementBySId(self, id):
        """
        getElementBySId(CompModelPlugin self, string id) -> SBase


        Returns the first child element found that has the given 'id' in the
        model-wide SId namespace, or 'None' if no such object is found.

        Parameter 'id' is a string representing the id of the object to find.

        Returns a pointer to the SBase element with the given 'id'.

        """
        return _libsbml.CompModelPlugin_getElementBySId(self, id)


    def getElementByMetaId(self, metaid):
        """
        getElementByMetaId(CompModelPlugin self, string metaid) -> SBase


        Returns the first child element it can find with the given meta
        identifier, or itself if it has the given 'metaid', or 'None' if no
        such object is found.

        Parameter 'metaid' is a string representing the metaid of the object
        to find.

        Returns a pointer to the SBase element with the given 'metaid'.

        """
        return _libsbml.CompModelPlugin_getElementByMetaId(self, metaid)


    def getListOfSubmodels(self, *args):
        """
        getListOfSubmodels(CompModelPlugin self) -> ListOfSubmodels
        getListOfSubmodels(CompModelPlugin self) -> ListOfSubmodels


        Returns the ListOfSubmodels from this CompModelPlugin.

        Returns the ListOfSubmodels from this CompModelPlugin.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addSubmodel(), createSubmodel(), getSubmodel(),
        getSubmodel(), getNumSubmodels(), removeSubmodel().

        """
        return _libsbml.CompModelPlugin_getListOfSubmodels(self, *args)


    def getSubmodel(self, *args):
        """
        getSubmodel(CompModelPlugin self, unsigned int n) -> Submodel
        getSubmodel(CompModelPlugin self, unsigned int n) -> Submodel
        getSubmodel(CompModelPlugin self, string id) -> Submodel
        getSubmodel(CompModelPlugin self, string id) -> Submodel


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getSubmodel(string id)

        Returns the submodel with the given identifier.

        Parameter 'id' is the identifier of the Submodel to get.

        Returns the Submodel in the ListOfSubmodels with the given identifier.
        If no submodel with identifier 'id' exists, 'None' is returned.

        ______________________________________________________________________
        Method variant with the following signature:

            getSubmodel(long n)

        Returns the submodel with the given index.

        Parameter 'n' is the index number of the Submodel to get.

        Returns the nth Submodel in the ListOfSubmodels.  If the index 'n' is
        invalid, 'None' is returned.

        """
        return _libsbml.CompModelPlugin_getSubmodel(self, *args)


    def addSubmodel(self, submodel):
        """
        addSubmodel(CompModelPlugin self, Submodel submodel) -> int


        Adds a copy of the given Submodel object to the list of submodels.

        Fails if the added submodel is 'None,' does not match the
        level/version/package of the parent object, or cannot be added to the
        list of submodels.

        Parameter 'submodel' is the Submodel object to be added to the list of
        submodels.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_PKG_VERSION_MISMATCH

        """
        return _libsbml.CompModelPlugin_addSubmodel(self, submodel)


    def getNumSubmodels(self):
        """
        getNumSubmodels(CompModelPlugin self) -> unsigned int


        Returns the number of submodels for this CompModelPlugin.

        Returns the number of submodels for this CompModelPlugin.

        """
        return _libsbml.CompModelPlugin_getNumSubmodels(self)


    def createSubmodel(self):
        """
        createSubmodel(CompModelPlugin self) -> Submodel


        Creates a Submodel object, adds it to the end of the submodel objects
        list and returns a pointer to the newly created object.

        Returns a newly created Submodel object.

        """
        return _libsbml.CompModelPlugin_createSubmodel(self)


    def removeSubmodel(self, index):
        """
        removeSubmodel(CompModelPlugin self, unsigned int index) -> Submodel


        Removes the submodel with the given index. A pointer to the submodel
        that was removed is returned. The caller owns the returned item and is
        responsible for deleting it.

        Parameter 'index' is the index of the Submodel object to remove.

        Returns the Submodel object removed.  As mentioned above, the caller
        owns the returned object. 'None' is returned if the given 'index' is
        out of range and no submodel has been removed, 'None' is returned.

        """
        return _libsbml.CompModelPlugin_removeSubmodel(self, index)


    def getListOfPorts(self, *args):
        """
        getListOfPorts(CompModelPlugin self) -> ListOfPorts
        getListOfPorts(CompModelPlugin self) -> ListOfPorts


        Returns the ListOfPorts from this CompModelPlugin.

        Returns the ListOfPorts from this CompModelPlugin.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addPort(), createPort(), getPort(), getPort(), getNumPorts(),
        removePort().

        """
        return _libsbml.CompModelPlugin_getListOfPorts(self, *args)


    def getPort(self, *args):
        """
        getPort(CompModelPlugin self, unsigned int n) -> Port
        getPort(CompModelPlugin self, unsigned int n) -> Port
        getPort(CompModelPlugin self, string id) -> Port
        getPort(CompModelPlugin self, string id) -> Port


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getPort(string id)

        Returns the port with the given identifier.

        Parameter 'id' is the id of the Port to get.

        Returns the Port in the ListOfPorts with the given identifier.  If the
        identifier is invalid, 'None' is returned.

        ______________________________________________________________________
        Method variant with the following signature:

            getPort(long n)

        Returns the port with the given index.

        Parameter 'n' is the index number of the Port to get.

        Returns the nth Port in the ListOfPorts. If the index 'n' is invalid,
        'None' is returned.

        """
        return _libsbml.CompModelPlugin_getPort(self, *args)


    def addPort(self, port):
        """
        addPort(CompModelPlugin self, Port port) -> int


        Adds a copy of the given Port object to the list of ports.

        Parameter 'port' is the Port object to be added to the list of ports.
        Fails if the added port is 'None,' does not match the
        level/version/package of the parent object, or cannot be added to the
        list of ports.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_PKG_VERSION_MISMATCH

        """
        return _libsbml.CompModelPlugin_addPort(self, port)


    def getNumPorts(self):
        """
        getNumPorts(CompModelPlugin self) -> unsigned int


        Returns the number of ports for this CompModelPlugin.

        Returns the number of ports for this CompModelPlugin.

        """
        return _libsbml.CompModelPlugin_getNumPorts(self)


    def createPort(self):
        """
        createPort(CompModelPlugin self) -> Port


        Creates a Port object, adds it to the end of the port objects list and
        returns a pointer to the newly created object.

        Returns a newly created Port object.

        """
        return _libsbml.CompModelPlugin_createPort(self)


    def removePort(self, index):
        """
        removePort(CompModelPlugin self, unsigned int index) -> Port


        Removes the port with the given index. The caller owns the returned
        item and is responsible for deleting it.

        Parameter 'index' is the index of the Port object to remove.

        Returns the Port object removed.  As mentioned above,  the caller owns
        the returned object. 'None' is returned if  the given index is out of
        range.

        """
        return _libsbml.CompModelPlugin_removePort(self, index)


    def setDivider(self, divider):
        """
        setDivider(CompModelPlugin self, string divider) -> int


        Set the string used as the divider between names when renaming and
        flattening models.

        The divider string consists of two underscore characters ("__") by
        default.  This method will fail if called with an empty 'divider', or
        a 'divider' that cannot be used internally as part of a valid SBML
        SId.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.CompModelPlugin_setDivider(self, divider)


    def getDivider(self):
        """
        getDivider(CompModelPlugin self) -> string


        Get the string used as the divider between names when renaming and
        flattening models.

        The divider string consists of two underscore characters ("__") by
        default, and can be overridden with the setDivider() function.

        Returns the divider that will be used by any call to flattenModel().

        See also setDivider().

        """
        return _libsbml.CompModelPlugin_getDivider(self)


    def connectToChild(self):
        """
        connectToChild(CompModelPlugin self)


        Internal implementation method.

        """
        return _libsbml.CompModelPlugin_connectToChild(self)


    def connectToParent(self, parent):
        """
        connectToParent(CompModelPlugin self, SBase parent)


        Internal implementation method.

        """
        return _libsbml.CompModelPlugin_connectToParent(self, parent)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(CompModelPlugin self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.CompModelPlugin_enablePackageInternal(self, pkgURI, pkgPrefix, flag)


    def setTransformer(self, transformer):
        """
        setTransformer(CompModelPlugin self, PrefixTransformer * transformer)


        Sets the custom transformer that is to be used, instead of the
        standard prefixing with the given divider. This makes it possible to
        finely control how elements are altered.

        If not set, only ids and meta ids will be prefixed.

        NOTE: the model plugin only holds the pointer to the element it does
        not  take ownership of it. Thus the calling program is responsible of
        freeing the transformer when no longer needed (i.e after the  SBML
        document has been deleted)

        Parameter 'transformer' is the prefix transformer to use.

        """
        return _libsbml.CompModelPlugin_setTransformer(self, transformer)


    def getTransformer(self):
        """
        getTransformer(CompModelPlugin self) -> PrefixTransformer *


        Returns any custom transformer set for prefix operations, will be None
        by default.

        """
        return _libsbml.CompModelPlugin_getTransformer(self)


    def isSetTransformer(self):
        """
        isSetTransformer(CompModelPlugin self) -> bool


        Returns an indicator, whether a custom transformer has been set.

        """
        return _libsbml.CompModelPlugin_isSetTransformer(self)


    def unsetTransformer(self):
        """
        unsetTransformer(CompModelPlugin self)


        Unsets any custom prefix transformers.

        """
        return _libsbml.CompModelPlugin_unsetTransformer(self)

CompModelPlugin_swigregister = _libsbml.CompModelPlugin_swigregister
CompModelPlugin_swigregister(CompModelPlugin)

class CompSBMLDocumentPlugin(SBMLDocumentPlugin):
    """

    [SBML 'comp' package]  Extension of SBMLDocument.

    The CompSBMLDocumentPlugin class inherits from the SBMLDocumentPlugin
    class, and codifies the extensions to the SBMLDocument class defined
    in the SBML Level 3 Hierarchical Model Composition ("comp") package.
    This extension allows multiple Model objects to be defined in a single
    SBMLDocument, stored in an optional child ListOfModelDefinitions
    object, as well as define references to Model objects in other files,
    stored in the optional child ListOfExternalModelDefinitions object.
    These model definitions, if present, allow Submodel objects to
    reference other Models to instantiate.

    The presence of any ModelDefinition or ExternalModelDefinition in an
    SBMLDocument does not change the default Model in the file.  If a
    SBMLDocument is submitted somewhere to be simulated, it is still the
    <model> child of the <sbml> element that should be simulated.

    In addition, as all packages do, the CompSBMLDocumentPlugin defines a
    required flag named required, which indicates whether  "comp"
    constructs can be used to change the core mathematics of the <model>
    child of the <sbml> element. Because they can, this attribute must be
    set 'True.'

    """

    __swig_setmethods__ = {}
    for _s in [SBMLDocumentPlugin]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CompSBMLDocumentPlugin, name, value)
    __swig_getmethods__ = {}
    for _s in [SBMLDocumentPlugin]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CompSBMLDocumentPlugin, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(CompSBMLDocumentPlugin self, string uri, string prefix, CompPkgNamespaces compns) -> CompSBMLDocumentPlugin
        __init__(CompSBMLDocumentPlugin self, CompSBMLDocumentPlugin orig) -> CompSBMLDocumentPlugin


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            CompSBMLDocumentPlugin(string &uri, string &prefix,
        CompPkgNamespaces compns)

        Creates a new CompSBMLDocumentPlugin object using the given
        parameters.

        In the XML representation of an SBML document, XML namespaces are
        used to identify the origin of each XML construct used.  XML
        namespaces are identified by their unique resource identifiers (URIs).
        The core SBML specifications stipulate the namespaces that must be
        used for core SBML constructs; for example, all XML elements that
        belong to SBML Level 3 Version 1 Core must be placed in the XML
        namespace identified by the URI
        'http://www.sbml.org/sbml/level3/version1/core'.  Individual SBML
        Level 3 packages define their own XML namespaces; for example, all
        elements belonging to the SBML Level 3 Layout Version 1 package must
        be placed in the XML namespace
        'http://www.sbml.org/sbml/level3/version1/layout/version1/'.

        The SBMLNamespaces object encapsulates SBML Level/Version/namespaces
        information.  It is used to communicate the SBML Level, Version, and
        (in Level 3) packages used in addition to SBML Level 3 Core.  A common
        approach to using libSBML's SBMLNamespaces facilities is to create an
        SBMLNamespaces object somewhere in a program once, then hand that
        object as needed to object constructors that accept SBMLNamespaces as
        arguments.

        Parameter 'uri' is the URI of the SBML Level 3 package implemented by
        this libSBML package extension.

        Parameter 'prefix' is the XML namespace prefix being used for the
        package.

        Parameter 'compns' is the namespaces object for the package.

        ______________________________________________________________________
        Method variant with the following signature:

            CompSBMLDocumentPlugin(CompSBMLDocumentPlugin orig)

        Copy constructor. Creates a copy of this CompSBMLDocumentPlugin
        object.

        Parameter 'orig' is the instance to copy.

        """
        this = _libsbml.new_CompSBMLDocumentPlugin(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_CompSBMLDocumentPlugin
    __del__ = lambda self: None

    def clone(self):
        """
        clone(CompSBMLDocumentPlugin self) -> CompSBMLDocumentPlugin


        Creates and returns a deep copy of this CompSBMLDocumentPlugin object.

        Returns a (deep) copy of this CompSBMLDocumentPlugin object.

        """
        return _libsbml.CompSBMLDocumentPlugin_clone(self)


    def getElementBySId(self, id):
        """
        getElementBySId(CompSBMLDocumentPlugin self, string id) -> SBase


        Returns the first child element found that has the given 'id' in the
        model-wide SId namespace, or 'None' if no such object is found.

        Parameter 'id' is string representing the identifier of the object to
        find.

        Returns a pointer to the SBase element with the given 'id'.

        Note: The comp SBML document plugin has multiple model-wide SId
        namespaces, so a valid document may well contain multiple elements
        with the same SId that reside in separate models.  It is not
        recommended to ever call this function---instead, call the function on
        the child ModelDefinition objects.

        """
        return _libsbml.CompSBMLDocumentPlugin_getElementBySId(self, id)


    def getElementByMetaId(self, metaid):
        """
        getElementByMetaId(CompSBMLDocumentPlugin self, string metaid) -> SBase


        Returns the first child element it can find with the given 'metaid',
        or itself if it has the given 'metaid', or 'None' if no such object is
        found.

        Parameter 'metaid' is string representing the meta identifier of the
        object to find.

        Returns a pointer to the SBase element with the given 'metaid'.

        """
        return _libsbml.CompSBMLDocumentPlugin_getElementByMetaId(self, metaid)


    def createObject(self, stream):
        """
        createObject(CompSBMLDocumentPlugin self, XMLInputStream stream) -> SBase


        Internal implementation method.

        """
        return _libsbml.CompSBMLDocumentPlugin_createObject(self, stream)


    def isCompFlatteningImplemented(self):
        """
        isCompFlatteningImplemented(CompSBMLDocumentPlugin self) -> bool


        Internal implementation method.

        """
        return _libsbml.CompSBMLDocumentPlugin_isCompFlatteningImplemented(self)


    def checkConsistency(self):
        """
        checkConsistency(CompSBMLDocumentPlugin self) -> unsigned int


        Internal implementation method.

        """
        return _libsbml.CompSBMLDocumentPlugin_checkConsistency(self)


    def getListOfModelDefinitions(self, *args):
        """
        getListOfModelDefinitions(CompSBMLDocumentPlugin self) -> ListOfModelDefinitions
        getListOfModelDefinitions(CompSBMLDocumentPlugin self) -> ListOfModelDefinitions


        Returns the ListOf object that holds each ModelDefinition.

        Returns the ListOf object that holds each ModelDefinition.

        """
        return _libsbml.CompSBMLDocumentPlugin_getListOfModelDefinitions(self, *args)


    def getModelDefinition(self, *args):
        """
        getModelDefinition(CompSBMLDocumentPlugin self, unsigned int n) -> ModelDefinition
        getModelDefinition(CompSBMLDocumentPlugin self, unsigned int n) -> ModelDefinition
        getModelDefinition(CompSBMLDocumentPlugin self, string sid) -> ModelDefinition
        getModelDefinition(CompSBMLDocumentPlugin self, string sid) -> ModelDefinition


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getModelDefinition(long n)

        Returns the ModelDefinition with the given index.

        Parameter 'n' is the index number of the ModelDefinition to get.

        Returns the nth ModelDefinition in the ListOfModelDefinitions.  If the
        index 'n' is invalid, 'None' is returned.

        ______________________________________________________________________
        Method variant with the following signature:

            getModelDefinition(string sid)

        Returns the model definition object based on its identifier.

        Parameter 'sid' is a string representing the identifier  of the model
        definition to get.

        Returns ModelDefinition in the ListOfModelDefinitions with the given
        'sid' or 'None' if no such ModelDefinition exists.

        See also getModelDefinition(), getListOfModelDefinitions().

        """
        return _libsbml.CompSBMLDocumentPlugin_getModelDefinition(self, *args)


    def addModelDefinition(self, modelDefinition):
        """
        addModelDefinition(CompSBMLDocumentPlugin self, ModelDefinition modelDefinition) -> int


        Adds a copy of the given ModelDefinition object to the
        ListOfModelDefinitions.

        Parameter 'modelDefinition' is the ModelDefinition object to be added
        to the ListOfModelDefinitions.  Fails if the added ModelDefinition is
        'None,' does not match the level/version/package of the parent object,
        or cannot be added to the list of replaced elements.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_PKG_VERSION_MISMATCH

        """
        return _libsbml.CompSBMLDocumentPlugin_addModelDefinition(self, modelDefinition)


    def getNumModelDefinitions(self):
        """
        getNumModelDefinitions(CompSBMLDocumentPlugin self) -> unsigned int


        Returns the number of ModelDefinition objects for this
        SBMLDocumentPlugin.

        Returns the number of ModelDefinition objects.

        """
        return _libsbml.CompSBMLDocumentPlugin_getNumModelDefinitions(self)


    def createModelDefinition(self):
        """
        createModelDefinition(CompSBMLDocumentPlugin self) -> ModelDefinition


        Creates a ModelDefinition object, adds it to the end of the
        ModelDefinition objects list and returns a pointer to the newly
        created object.

        Returns a newly created ModelDefinition object.

        """
        return _libsbml.CompSBMLDocumentPlugin_createModelDefinition(self)


    def removeModelDefinition(self, *args):
        """
        removeModelDefinition(CompSBMLDocumentPlugin self, unsigned int index) -> ModelDefinition
        removeModelDefinition(CompSBMLDocumentPlugin self, string id) -> ModelDefinition


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeModelDefinition(string id)

        Removes the ModelDefinition with the given 'id' from the
        CompSBMLDocumentPlugin.

        A pointer to the ModelDefinition that was removed is returned. If no
        ModelDefinition has been removed, 'None' is returned.

        Parameter 'id' is the id of the ModelDefinition object to remove.

        Returns the ModelDefinition object removed.  As mentioned above,  the
        caller owns the returned object. 'None' is returned if  the given
        index is out of range.

        ______________________________________________________________________
        Method variant with the following signature:

            removeModelDefinition(long index)

        Removes the ModelDefinition with the given index from the
        CompSBMLDocumentPlugin.

        A pointer to the ModelDefinition that was removed is returned. If no
        ModelDefinition has been removed, 'None' is returned.

        Parameter 'index' is the index of the ModelDefinition object to
        remove.

        Returns the ModelDefinition object removed.  As mentioned above,  the
        caller owns the returned object. 'None' is returned if  the given
        index is out of range.

        """
        return _libsbml.CompSBMLDocumentPlugin_removeModelDefinition(self, *args)


    def getListOfExternalModelDefinitions(self, *args):
        """
        getListOfExternalModelDefinitions(CompSBMLDocumentPlugin self) -> ListOfExternalModelDefinitions
        getListOfExternalModelDefinitions(CompSBMLDocumentPlugin self) -> ListOfExternalModelDefinitions


        Returns the ListOf object that holds each ExternalModelDefinition.

        Returns the ListOf object that each all ExternalModelDefinition.

        """
        return _libsbml.CompSBMLDocumentPlugin_getListOfExternalModelDefinitions(self, *args)


    def getExternalModelDefinition(self, *args):
        """
        getExternalModelDefinition(CompSBMLDocumentPlugin self, unsigned int n) -> ExternalModelDefinition
        getExternalModelDefinition(CompSBMLDocumentPlugin self, unsigned int n) -> ExternalModelDefinition
        getExternalModelDefinition(CompSBMLDocumentPlugin self, string sid) -> ExternalModelDefinition
        getExternalModelDefinition(CompSBMLDocumentPlugin self, string sid) -> ExternalModelDefinition


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getExternalModelDefinition(long n)

        Returns the ExternalModelDefinition with the given index.

        Parameter 'n' is the index number of the ExternalModelDefinition to
        get.

        Returns the nth ExternalModelDefinition in the
        ListOfExternalModelDefinitions.  If the index is invalid, 'None' is
        returned.

        ______________________________________________________________________
        Method variant with the following signature:

            getExternalModelDefinition(string sid)

        Returns the model definition object based on its identifier.

        Parameter 'sid' is a string representing the identifier  of the model
        definition to get.

        Returns ExternalModelDefinition in the ListOfExternalModelDefinitions
        with the given 'sid' or 'None' if no such ExternalModelDefinition
        exists.

        See also getExternalModelDefinition(),
        getListOfExternalModelDefinitions().

        """
        return _libsbml.CompSBMLDocumentPlugin_getExternalModelDefinition(self, *args)


    def getModel(self, *args):
        """
        getModel(CompSBMLDocumentPlugin self, string sid) -> SBase
        getModel(CompSBMLDocumentPlugin self, string sid) -> SBase


        Searches the model namespace of the document and returns the Model,
        ModelDefinition, or ExternalModelDefintion object with the given
        identifier.

        Parameter 'sid' is a string representing the identifier of the model
        definition to get.

        Returns The SBase corresponding to the given 'sid' or 'None' if no
        such model exists.  If no such model exists, this will return 'None.'

        """
        return _libsbml.CompSBMLDocumentPlugin_getModel(self, *args)


    def setRequired(self, value):
        """
        setRequired(CompSBMLDocumentPlugin self, bool value) -> int


        Sets the bool value of 'required' attribute of corresponding package
        in SBMLDocument element.  The only legal value is 'true' for the
        Hierarchical Model Composition package.

        Parameter 'value' is the bool value of 'required' attribute of
        corresponding  package in SBMLDocument element.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.CompSBMLDocumentPlugin_setRequired(self, value)


    def addExternalModelDefinition(self, externalModelDefinition):
        """
        addExternalModelDefinition(CompSBMLDocumentPlugin self, ExternalModelDefinition externalModelDefinition) -> int


        Adds a copy of the given ExternalModelDefinition object to the
        ListOfExternalModelDefinitions.

        Parameter 'externalModelDefinition' is the ExternalModelDefinition
        object to be added to the ListOFExternalModelDefinitions.  Fails if
        the added ExternalModelDefinition is 'None,' does not match the
        level/version/package of the parent object, or cannot be added to the
        list of external model definitions.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_PKG_VERSION_MISMATCH

        """
        return _libsbml.CompSBMLDocumentPlugin_addExternalModelDefinition(self, externalModelDefinition)


    def getNumExternalModelDefinitions(self):
        """
        getNumExternalModelDefinitions(CompSBMLDocumentPlugin self) -> unsigned int


        Returns the number of ExternalModelDefinition objects for this
        SBMLDocumentPlugin.

        Returns the number of ExternalModelDefinition objects for this
        SBMLDocumentPlugin.

        """
        return _libsbml.CompSBMLDocumentPlugin_getNumExternalModelDefinitions(self)


    def createExternalModelDefinition(self):
        """
        createExternalModelDefinition(CompSBMLDocumentPlugin self) -> ExternalModelDefinition


        Creates a ExternalModelDefinition object, adds it to the end of the
        ExternalModelDefinition objects list and returns a pointer to the
        newly created object.

        Returns a newly created ExternalModelDefinition object.

        """
        return _libsbml.CompSBMLDocumentPlugin_createExternalModelDefinition(self)


    def removeExternalModelDefinition(self, *args):
        """
        removeExternalModelDefinition(CompSBMLDocumentPlugin self, unsigned int index) -> ExternalModelDefinition
        removeExternalModelDefinition(CompSBMLDocumentPlugin self, string id) -> ExternalModelDefinition


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeExternalModelDefinition(string id)

        Removes the ExternalModelDefinition with the given 'id'.

        A pointer to the ExternalModelDefinition that was removed is returned.
        If no ExternalModelDefinition has been removed, 'None' is returned.

        Parameter 'id' is the id of the ExternalModelDefinition object to
        remove.

        Returns the ExternalModelDefinition object removed.  As mentioned
        above,  the caller owns the returned object. 'None' is returned if
        the given index is out of range.

        ______________________________________________________________________
        Method variant with the following signature:

            removeExternalModelDefinition(long index)

        Removes the ExternalModelDefinition with the given index.

        A pointer to the ExternalModelDefinition that was removed is returned.
        If no ExternalModelDefinition has been removed, 'None' is returned.

        Parameter 'index' is the index of the ExternalModelDefinition object
        to remove.

        Returns the ExternalModelDefinition object removed.  As mentioned
        above,  the caller owns the returned object. 'None' is returned if
        the given index is out of range.

        """
        return _libsbml.CompSBMLDocumentPlugin_removeExternalModelDefinition(self, *args)


    def connectToChild(self):
        """
        connectToChild(CompSBMLDocumentPlugin self)


        Internal implementation method.

        """
        return _libsbml.CompSBMLDocumentPlugin_connectToChild(self)


    def connectToParent(self, parent):
        """
        connectToParent(CompSBMLDocumentPlugin self, SBase parent)


        Internal implementation method.

        """
        return _libsbml.CompSBMLDocumentPlugin_connectToParent(self, parent)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(CompSBMLDocumentPlugin self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.CompSBMLDocumentPlugin_enablePackageInternal(self, pkgURI, pkgPrefix, flag)


    def getOverrideCompFlattening(self):
        """
        getOverrideCompFlattening(CompSBMLDocumentPlugin self) -> bool


        Internal implementation method.

        """
        return _libsbml.CompSBMLDocumentPlugin_getOverrideCompFlattening(self)


    def setOverrideCompFlattening(self, overrideCompFlattening):
        """
        setOverrideCompFlattening(CompSBMLDocumentPlugin self, bool overrideCompFlattening)


        Internal implementation method.

        """
        return _libsbml.CompSBMLDocumentPlugin_setOverrideCompFlattening(self, overrideCompFlattening)


    def getSBMLDocumentFromURI(self, uri):
        """
        getSBMLDocumentFromURI(CompSBMLDocumentPlugin self, string uri) -> SBMLDocument


        Internal implementation method.

        """
        return _libsbml.CompSBMLDocumentPlugin_getSBMLDocumentFromURI(self, uri)

CompSBMLDocumentPlugin_swigregister = _libsbml.CompSBMLDocumentPlugin_swigregister
CompSBMLDocumentPlugin_swigregister(CompSBMLDocumentPlugin)

class SBMLUri(_object):
    """

    [SBML 'comp' package]  Utility class for handling URIs.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  It is a class used in the
    implementation of extra functionality provided by libSBML.

    This class implements functionality for parsing URIs and extracting
    information about them.

    See also SBMLResolver, SBMLFileResolver.

    """

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLUri, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SBMLUri, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(SBMLUri self, string uri) -> SBMLUri
        __init__(SBMLUri self, SBMLUri orig) -> SBMLUri


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            SBMLUri(string uri)

        Creates a new SBMLUri from the given string URI.

        ______________________________________________________________________
        Method variant with the following signature:

            SBMLUri(SBMLUri orig)

        Copy constructor.  Creates a copy of an SBMLUri object.

        Parameter 'orig' is the SBMLUri object to copy.

        """
        this = _libsbml.new_SBMLUri(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_SBMLUri
    __del__ = lambda self: None

    def clone(self):
        """
        clone(SBMLUri self) -> SBMLUri


        Creates and returns a deep copy of this SBMLUri object.

        Returns a (deep) copy of this SBMLFileResolver object.

        """
        return _libsbml.SBMLUri_clone(self)


    def getScheme(self):
        """
        getScheme(SBMLUri self) -> string


        Returns the scheme of the stored URI.

        The scheme of the URI is the text before the first colon character.
        Typical examples of what this might return are the strings ''file'' or
        ''http'.'  If the current URI does not have a scheme, this method
        returns an empty string.

        Returns the parsed scheme, such as ''http',' or an empty string if no
        scheme exists for the current URI.

        """
        return _libsbml.SBMLUri_getScheme(self)


    def getHost(self):
        """
        getHost(SBMLUri self) -> string


        Returns the host portion of the stored URI.

        For a scheme such as ''http',' this method returns the part of the URI
        after ''http://'' and before the next ''/'' character.  URIs with file
        or URN schemes have no host; in that case, this method returns an
        empty string.

        Returns the host of the URI, or an empty string in the case of files
        or URNs schemes that do not possess a host portion.

        """
        return _libsbml.SBMLUri_getHost(self)


    def getPath(self):
        """
        getPath(SBMLUri self) -> string


        Returns the path and filename portion of the stored URI.

        This method returns the text after the scheme, colon, and host (if
        present), and before the next ''?'' character.  The result may be an
        empty string for some URIs.

        Returns the path of the URI (i.e., the full filename with path).

        """
        return _libsbml.SBMLUri_getPath(self)


    def getQuery(self):
        """
        getQuery(SBMLUri self) -> string


        Returns the query portion of the stored URI.

        The equery portion of a URI is the text after a filename, starting
        with the character ''?'.'  For many URIs, this is an empty string.

        Returns the query of the URI (i.e., the part after the full filename
        with path).

        """
        return _libsbml.SBMLUri_getQuery(self)


    def getUri(self):
        """
        getUri(SBMLUri self) -> string


        Returns the full stored URI, after replacing backslashes with slashes.

        Returns the original URI, with backslashes replaced with slashes.

        """
        return _libsbml.SBMLUri_getUri(self)


    def relativeTo(self, uri):
        """
        relativeTo(SBMLUri self, string uri) -> SBMLUri


        Constructs a new URI relative to this object and the given URI.

        For example,

          SBMLUri('c:\test').relativeTo('test.xml')

        would construct a new file URI, with path c:/test/test.xml.

        Parameter 'uri' is a URI to be added to this object.

        Returns the resulting new URI.

        """
        return _libsbml.SBMLUri_relativeTo(self, uri)

SBMLUri_swigregister = _libsbml.SBMLUri_swigregister
SBMLUri_swigregister(SBMLUri)

class SBMLResolver(_object):
    """

    [SBML 'comp' package]  Base class for SBML resolvers.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  It is a class used in the
    implementation of extra functionality provided by libSBML.

    The SBMLResolver class is the base class for the various SBML
    resolvers: facilities that take a unique identifier as input and
    return the document associated with that identifier.  In SBML,
    resolvers come into play with the SBML Level 3 Hierarchical Model
    Composition package; this package includes features that allow a model
    to be composed from pieces that are external to a given SBML document,
    which implies the need to be able to identify and locate those
    external pieces.  The SBMLResolver class and its subclasses provide
    facilities for software applications to be able to do these tasks.

    LibSBML provides a number of built-in resolvers, and applications can
    create their own by subclassing SBMLResolver and following the
    examples of the existing resolvers.  The following are the built-in
    resolvers in libSBML 5.18.0 :

    * SBMLFileResolver

    More resolvers may be provided by libSBML in the future.  Application
    authors may also write their own.

    See also SBMLUri.

    """

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLResolver, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SBMLResolver, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(SBMLResolver self) -> SBMLResolver
        __init__(SBMLResolver self, SBMLResolver c) -> SBMLResolver


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            SBMLResolver()

        Creates a new SBMLResolver object.

        ______________________________________________________________________
        Method variant with the following signature:

            SBMLResolver(SBMLResolver c)

        Copy constructor.  Creates a copy of an SBMLResolver object.

        Parameter 'c' is the SBMLResolver object to copy.

        """
        if self.__class__ == SBMLResolver:
            _self = None
        else:
            _self = self
        this = _libsbml.new_SBMLResolver(_self, *args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_SBMLResolver
    __del__ = lambda self: None

    def clone(self):
        """
        clone(SBMLResolver self) -> SBMLResolver


        Creates and returns a deep copy of this SBMLResolver object.

        Returns a (deep) copy of this SBMLResolver object.

        """
        return _libsbml.SBMLResolver_clone(self)


    def resolve(self, *args):
        """
        resolve(SBMLResolver self, string uri, string baseUri) -> SBMLDocument
        resolve(SBMLResolver self, string uri) -> SBMLDocument


        Resolves the document for the given URI.

        Parameter 'uri' is the URI to the target document. Parameter 'baseUri'
        is base URI, in case the URI is a relative one.

        Returns the document, if this resolver can resolve the document or
        'None.'

        """
        return _libsbml.SBMLResolver_resolve(self, *args)


    def resolveUri(self, *args):
        """
        resolveUri(SBMLResolver self, string uri, string baseUri) -> SBMLUri
        resolveUri(SBMLResolver self, string uri) -> SBMLUri


        Resolves the full URI for the given URI without actually reading the
        document.

        Parameter 'uri' is the URI to the target document. Parameter 'baseUri'
        is base URI, in case the URI is a relative one.

        Returns the full URI to the document, if this resolver can resolve the
        document or 'None.'

        """
        return _libsbml.SBMLResolver_resolveUri(self, *args)

    def __disown__(self):
        self.this.disown()
        _libsbml.disown_SBMLResolver(self)
        return weakref_proxy(self)
SBMLResolver_swigregister = _libsbml.SBMLResolver_swigregister
SBMLResolver_swigregister(SBMLResolver)

class SBMLFileResolver(SBMLResolver):
    """

    [SBML 'comp' package]  Resolves documents stored on a file system.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  It is a class used in the
    implementation of extra functionality provided by libSBML.

    In SBML, resolvers come into play with the SBML Level 3 Hierarchical
    Model Composition package ("comp"); this package includes features
    that allow a model to be composed from pieces that are external to a
    given SBML document, which implies the need to be able to identify and
    locate those external pieces.  The identifiers used in "comp" are
    URIs (Uniform Resource Identifiers).

    SBMLFileResolver is a class implementing the ability to resolve URIs
    to files.  It works on the local file system only.  It can resolve
    relative and absolute paths, and directories to be searched can be
    specified using the methods  SBMLFileResolver.addAdditionalDir() and
    SBMLFileResolver.clearAdditionalDirs().

    See also SBMLResolver, SBMLUri.

    """

    __swig_setmethods__ = {}
    for _s in [SBMLResolver]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLFileResolver, name, value)
    __swig_getmethods__ = {}
    for _s in [SBMLResolver]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SBMLFileResolver, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(SBMLFileResolver self) -> SBMLFileResolver
        __init__(SBMLFileResolver self, SBMLFileResolver c) -> SBMLFileResolver


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            SBMLFileResolver(SBMLFileResolver c)

        Copy constructor.  Creates a copy of an SBMLFileResolver object.

        Parameter 'c' is the SBMLFileResolver object to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            SBMLFileResolver()

        Creates a new SBMLFileResolver object.

        """
        this = _libsbml.new_SBMLFileResolver(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_SBMLFileResolver
    __del__ = lambda self: None

    def clone(self):
        """
        clone(SBMLFileResolver self) -> SBMLFileResolver


        Creates and returns a deep copy of this SBMLFileResolver object.

        Returns a (deep) copy of this SBMLFileResolver object.

        """
        return _libsbml.SBMLFileResolver_clone(self)


    def resolve(self, *args):
        """
        resolve(SBMLFileResolver self, string uri, string baseUri) -> SBMLDocument
        resolve(SBMLFileResolver self, string uri) -> SBMLDocument


        Resolves the document for the given URI.

        Parameter 'uri' is the URI to the target document. Parameter 'baseUri'
        is base URI, in case the URI is a relative one.

        Returns the document, if this resolver can resolve the document or
        'None.'

        """
        return _libsbml.SBMLFileResolver_resolve(self, *args)


    def resolveUri(self, *args):
        """
        resolveUri(SBMLFileResolver self, string uri, string baseUri) -> SBMLUri
        resolveUri(SBMLFileResolver self, string uri) -> SBMLUri


        Resolves the full URI for a given URI without actually reading the
        document.

        Parameter 'uri' is the URI to the target document. Parameter 'baseUri'
        is base URI, in case the URI is a relative one.

        Returns the full URI to the document, if this resolver can resolve the
        document or 'None.'

        """
        return _libsbml.SBMLFileResolver_resolveUri(self, *args)


    def clearAdditionalDirs(self):
        """
        clearAdditionalDirs(SBMLFileResolver self)


        Removes the list of directories to search for files to resolve.

        After this method is called, SBMLFileResolver.resolve() will only
        search absolute or relative directories.  New directories can be added
        using SBMLFileResolver.addAdditionalDir() .

        See also addAdditionalDir().

        """
        return _libsbml.SBMLFileResolver_clearAdditionalDirs(self)


    def addAdditionalDir(self, dir):
        """
        addAdditionalDir(SBMLFileResolver self, string dir)


        Adds a directory to the list of directories to search for files to
        resolve.

        Parameter 'dir' is the directory to add.

        See also clearAdditionalDirs().

        """
        return _libsbml.SBMLFileResolver_addAdditionalDir(self, dir)

SBMLFileResolver_swigregister = _libsbml.SBMLFileResolver_swigregister
SBMLFileResolver_swigregister(SBMLFileResolver)

class SBMLResolverRegistry(_object):
    """

    [SBML 'comp' package]  Registry of all SBML resolvers.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  It is a class used in the
    implementation of extra functionality provided by libSBML.

    LibSBML provides facilities for resolving SBML documents in various
    ways from a given URI. Resolvers are implemented as objects derived
    from the class SBMLResolver.

    The resolver registry maintains a list of known resolvers and provides
    methods for discovering them.  It is implemented as a singleton object
    of class SBMLResolverRegistry.  Callers can use the method
    SBMLResolverRegistry.getNumResolvers() to find out how many resolvers
    are registered, then use SBMLResolverRegistry.getResolverByIndex() to
    iterate over each one;

    See also SBMLFileResolver.

    """

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLResolverRegistry, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SBMLResolverRegistry, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def getInstance():
        """
        getInstance() -> SBMLResolverRegistry


        Returns the singleton instance for the resolver registry.

        Prior to using the registry, callers have to obtain a copy of the
        registry.  This static method provides the means for doing that.

        Returns the singleton for the resolver registry.

        """
        return _libsbml.SBMLResolverRegistry_getInstance()

    getInstance = staticmethod(getInstance)

    def addResolver(self, resolver):
        """
        addResolver(SBMLResolverRegistry self, SBMLResolver resolver) -> int


        Adds the given resolver to the registry of SBML resolvers.

        Parameter 'resolver' is the resolver to add to the registry.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_OBJECT

        """
        return _libsbml.SBMLResolverRegistry_addResolver(self, resolver)


    def addOwnedSBMLDocument(self, doc):
        """
        addOwnedSBMLDocument(SBMLResolverRegistry self, SBMLDocument doc) -> int


        Adds the given SBMLDocument to the registry of SBML documents that
        will need to be deleted.

        When calculating reference cycles, sometimes we need SBML Documents to
        persist, but nobody else owns them directly.  We hand them to the
        registry here so they can be cleaned up

        Parameter 'doc' is the SBML Document to add to the registry.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_OBJECT

        """
        return _libsbml.SBMLResolverRegistry_addOwnedSBMLDocument(self, doc)


    def removeResolver(self, index):
        """
        removeResolver(SBMLResolverRegistry self, int index) -> int


        Removes the resolver with the given index.

        Parameter 'index' is the index of the resolver to be removed.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_OBJECT

        """
        return _libsbml.SBMLResolverRegistry_removeResolver(self, index)


    def getResolverByIndex(self, index):
        """
        getResolverByIndex(SBMLResolverRegistry self, int index) -> SBMLResolver


        Returns the resolver with the given index number.

        Resolvers are given arbitrary index numbers by the registry.  Callers
        can use the method SBMLResolverRegistry.getNumResolvers() to find out
        how many resolvers are registered, then use this method to iterate
        over the list and obtain each one in turn.

        Parameter 'index' is the zero-based index of the resolver to fetch.

        Returns the resolver with the given index number, or 'None' if the
        number is less than '0' or there is no resolver at the given index
        position.

        """
        return _libsbml.SBMLResolverRegistry_getResolverByIndex(self, index)


    def getNumResolvers(self):
        """
        getNumResolvers(SBMLResolverRegistry self) -> int


        Returns the number of resolvers known by the registry.

        Returns the number of registered resolvers.

        See also getResolverByIndex().

        """
        return _libsbml.SBMLResolverRegistry_getNumResolvers(self)

    __swig_destroy__ = _libsbml.delete_SBMLResolverRegistry
    __del__ = lambda self: None

    def resolve(self, *args):
        """
        resolve(SBMLResolverRegistry self, string uri, string baseUri) -> SBMLDocument
        resolve(SBMLResolverRegistry self, string uri) -> SBMLDocument


        Resolves the document for the given URI.

        Parameter 'uri' is the URI to the target document. Parameter 'baseUri'
        is base URI, in case the URI is a relative one.

        Returns the document, if this resolver can resolve the document or
        'None.'

        """
        return _libsbml.SBMLResolverRegistry_resolve(self, *args)


    def resolveUri(self, *args):
        """
        resolveUri(SBMLResolverRegistry self, string uri, string baseUri) -> SBMLUri
        resolveUri(SBMLResolverRegistry self, string uri) -> SBMLUri


        Resolves the full URI for the given URI without actually reading the
        document.

        Parameter 'uri' is the URI to the target document. Parameter 'baseUri'
        is base URI, in case the URI is a relative one.

        Returns the full URI to the document, if this resolver can resolve the
        document or 'None.'

        """
        return _libsbml.SBMLResolverRegistry_resolveUri(self, *args)


    def deleteResolerRegistryInstance():
        """
        deleteResolerRegistryInstance()


        deletes the static resolver registry instance

        """
        return _libsbml.SBMLResolverRegistry_deleteResolerRegistryInstance()

    deleteResolerRegistryInstance = staticmethod(deleteResolerRegistryInstance)
SBMLResolverRegistry_swigregister = _libsbml.SBMLResolverRegistry_swigregister
SBMLResolverRegistry_swigregister(SBMLResolverRegistry)

def SBMLResolverRegistry_getInstance():
    """
    SBMLResolverRegistry_getInstance() -> SBMLResolverRegistry


    Returns the singleton instance for the resolver registry.

    Prior to using the registry, callers have to obtain a copy of the
    registry.  This static method provides the means for doing that.

    Returns the singleton for the resolver registry.

    """
    return _libsbml.SBMLResolverRegistry_getInstance()

def SBMLResolverRegistry_deleteResolerRegistryInstance():
    """
    SBMLResolverRegistry_deleteResolerRegistryInstance()


    deletes the static resolver registry instance

    """
    return _libsbml.SBMLResolverRegistry_deleteResolerRegistryInstance()

class CompFlatteningConverter(SBMLConverter):
    """

    [SBML 'comp' package]  'Flattens' a model, removing composition.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  It is a class used in the
    implementation of extra functionality provided by libSBML.

    This converter translates a hierarchical model defined with the SBML
    Level 3 Hierarchical Model Composition package to a so-called
    'flattened' version of the same model.  A 'flattened' model is one
    that results from interpreting the hierarchical structure and creating
    an equivalent model that does not use any Hierarchical Model
    Composition package constructs; all of the mathematics of the model
    remain as intended, but the hierarchical structure is removed.
    CompFlatteningConverter achieves this by performing the following
    actions on a model: <ol>

    * Each submodel is instantiated; that is, a copy of every Model
    object referenced by every Submodel object is created.  This is a
    recursive process: if the instantiated Model itself has Submodel
    children, they are also instantiated.

    * The identifier of every component object in every Model that is
    instantiated is modified by prepending a prefix to it, to make the
    identifier unique in the overall flattened SBML model.  The prefix
    consists of the Submodel object identifier, plus a small integer if
    necessary to ensure uniqueness, plus two underscore characters ('__').
    Typically, this results in a final identifier of the form
    SubmodelIdentifier__ObjectIdentifier, where ObjectIdentifier is the
    object's original identifier and SubmodelIdentifier__ is the prefix.
    The same process is applied to metaid (meta-identifier) values of
    every component object as well.

    * All deleted elements are removed from the model and all instantiated
    submodels.

    * All replaced elements are removed from the model and all
    instantiated submodels.

    * All references to replaced elements are changed to point to the
    replacement element instead.

    * All remaining elements are placed in a single Model object; this
    Model object is made the new child of the SBMLDocument container.  The
    original Model, ModelDefinition, and ExternalModelDefinition objects
    are all deleted.

    </ol>

    Note an implication of this process is that if conversion is
    successful, all old pointers to the SBMLDocument object's Model object
    as well as all of its children, will be rendered obsolete, and will no
    longer work.

    Summary of options for CompFlatteningConverter
    ======================================================================

    CompFlatteningConverter is enabled by creating a ConversionProperties
    object with the option 'flatten comp', and passing this
    ConversionProperties object to SBMLDocument.convert().  The
    CompFlatteningConverter converter accepts numerous options influencing
    its behavior.  The following list briefly summarizes the options:

    * 'flatten comp': Possible values are ''True'' or ''False'.' Setting
    the option to 'True' (the default) means enable the flattening
    converter.

    * 'abortIfUnflattenable': Possible values are ''all','
    ''requiredOnly'' (the default), or ''none'.'  Controls what happens
    upon encountering an SBML Level 3 package with no flattener
    implementation.

    * 'stripUnflattenablePackages': Possible values are ''True'' or
    ''False'' (the default).  Controls whether the constructs of Level 3
    packages with no flattener implementation are stripped from the
    output.

    * 'stripPackages': The value must be a string representing a comma-
    separated list of SBML Level 3 packages to be stripped before
    conversion.  (Default value: empty string, meaning, no packages.)

    * 'basePath': The value must be a string representing the path where
    the converter should search for any ExternalModelDefinition objects.
    (Default value: '.', meaning, the current directory.)

    * 'leavePorts': Possible values are ''True'' or ''False'' (the
    default).  Controls what happens to Port constructs in the output.

    * 'listModelDefinitions': Possible values are ''True'' or ''False''
    (the default).  Controls what happens to ModelDefinition and
    ExternalModelDefinition objects in the final output.

    * 'performValidation': Possible values are ''True'' (the default) or
    ''False'.'  Controls whether whether libSBML validates the model
    before attempting to flatten it. options-details Detailed explanation of available options
    ======================================================================

    The following sections examine in detail the options understood by
    CompFlatteningConverter and their effects on the flattening process.

    Options for handling Level 3 packages
    ......................................................................

    If other SBML Level 3 packages are used in the SBMLDocument, the same
    rules apply to each package's constructs if an implementation of the
    flattener exists for that Level 3 package.  If no implementation
    exists, the behavior of this CompFlatteningConverter depends on the
    values of the options 'abortIfUnflattenable' and
    'stripUnflattenablePackages'.  Specifically:

    * The option 'abortIfUnflattenable' controls whether the flattening
    process is abandoned.  The following are the possible values for this
    option and their meanings:

    * If the 'abortIfUnflattenable' option is set to ''all',' then if any
    construct is found for a package that has no flattening algorithm
    available, the converter will abort, return failure, and avoid
    changing the original SBMLDocument object.

    * If 'abortIfUnflattenable' is set to ''requiredOnly'' (the default),
    then if any SBML Level 3 package construct is found for a package that
    is labeled ''required=true'' and for which no flattening algorithm is
    available, the converter will abort, return failure, and avoid
    changing the original SBMLDocument object.  SBML Level 3 package
    constructs from packages set ''required=false'' for which no
    flattening algorithm is implemented will be ignored and the constructs
    will be kept or removed depending on the value of the
    'stripUnflattenablePackages' option described below.

    * If 'abortIfUnflattenable' is set to ''none',' constructs from all
    unflattenable SBML Level 3 packages will be ignored, and their
    constructs will be kept or removed depending on the value of the
    'stripUnflattenablePackages' option.

    * The option 'stripUnflattenablePackages' controls whether SBML Level
    3 package constructs are removed from the final flattened model.  The
    following are the possible values for this option and their meanings:

    * If the option 'stripUnflattenablePackages' is set to ''True',' and
    the option 'abortIfUnflattenable' has the value ''requiredOnly'' or
    ''none',' then CompFlatteningConverter will remove all constructs
    belonging to packages that lack a flattening converter.  The XML
    namespace declaration for unflattenable SBML Level 3 packages will
    also be removed.

    * If the option 'stripUnflattenablePackages' is set to ''False'' (the
    default), CompFlatteningConverter will leave any package constructs
    that cannot be flattened due to the lack of a flattening
    implementation.  These Level 3 package constructs will remain in the
    final model.  Note that any package constructs from an instantiated
    Submodel object that was not a child of a retained component will be
    lost (because the SBML component where it was located was removed from
    the final, flattened model).

    * The option 'stripPackages' controls whether SBML Level 3 package
    information is stripped from a model before conversion. Regardless of
    the above options, if an SBML package is listed in this comma-
    separated list, all constructs from that package will be removed from
    the model before the flattening algorithm is applied.  This happens
    whether a flattening algorithm exists for that package or not, and
    applies to all referenced models, both local and external.  In
    addition, the removal takes place before any validation is performed
    by libSBML.

    Additional general conversion options for CompFlatteningConverter
    ......................................................................

    The following are other, general options offered by
    CompFlatteningConverter:

    * 'basePath': if there are ExternalModelDefinition objects that
    are to be instantiated in a flattened Submodel, the 'basePath' option
    may be set to a location where those external models may be found.
    The default is the working directory (''.').'

    * 'leavePorts': if this option is set to ''False'' (the default),
    the flattened model will have no Port objects in it.  Conversely, if
    'leavePorts' is set to ''True',' any Port objects not referenced by
    any Replacement or Deletion will be left in the resulting flattened
    Model.

    * 'listModelDefinitions': If this option is set to ''False'' (the
    default), no ModelDefinition or ExternalModelDefinition objects will
    be present in the flattened SBMLDocument.  If 'listModelDefinitions'
    is set to ''True',' they will remain, although they will no longer be
    referenced by any Submodel in the flattened Model child of the
    SBMLDocument.

    * 'performValidation': if this option is set to ''True'' (the
    default), the SBMLDocument will first be validated before flattening
    is attempted.  If there are any validation errors, those errors will
    be logged with the SBMLDocument, which will remain otherwise
    unchanged, and the conversion process will return a failure code.
    Similarly, if the flattened Model is not valid, those validation
    errors will be added to the SBMLDocument, which will remain otherwise
    unchanged, and the conversion attempt will return failure. Conversely,
    if the option 'performValidation' is set to ''False',' the
    SBMLDocument will be flattened regardless of any validation errors.
    The conversion may yet fail if insurmountable errors are encountered
    in the course of trying to flatten the model (for instance, if an
    element is replaced by something that does not exist), but no separate
    validation steps are performed.

    Note that if both the option 'leavePorts' and 'listModelDefinitions'
    are set to ''False'' (which they are by default), the Hierarchical
    Model Composition namespace will be removed from the resulting
    SBMLDocument.

    Complete example of invoking CompFlatteningConverter
    ======================================================================

    In this section, we present a complete example of a program that can
    take an SBML model containing Level 3 Hierarchical Model Composition
    constructs and flatten it to a plain SBML Level 3 model. A version of
    this program is available in the libSBML distribution's
    examples/python/comp directory as the program named .py
    'flattenModel.py'.  The example XML models shown below are the same
    models as given in sections 4.1-4.2 in the specification document for
    SBML Level 3 Hierarchical Model Composition.

    Example program
    ......................................................................

    For brevity, we do not give the general scaffolding that a real
    program would have (such as inclusion of header files, command-line
    argument checks, additional error checks throughout the code, and so
    on), and focus instead on the parts relevant to an application using
    the libSBML 'comp' extension.

    First, our program checks that this copy of libSBML has the 'comp'
    extension available.  The process for doing that simply involves a
    call to the extension registry in libSBML:

      if not SBMLExtensionRegistry.isPackageEnabled('comp'):
          err_msg = 'This copy of libSBML does not contain the 'comp' extension.'
          raise SystemExit(err_msg)

    Next, we read the SBML input file.  For this example, we simply
    assume that the path to the file is given as the first argument to the
    program; a real program would perform more sophisticated command-line
    argument processing and error checking.

      reader  = SBMLReader()
      sbmldoc = reader.readSBML(args[1])
      if sbmldoc.getNumErrors() > 0:
          sbmldoc.printErrors()
          raise SystemExit(2)

    Continuing, we set up options for the call to the converter. The use
    of ConversionProperties and the general scheme behind conversion
    options is explained further below; for the purposes of this example,
    it is enough to know that the following are the basic lines of code
    needed to obtain a copy of a libSBML converter object that will invoke
    CompFlatteningConverter:

      props = ConversionProperties()
      props.addOption('flatten comp', True)       # Invokes CompFlatteningConverter

    Now comes the actual invocation of CompFlatteningConverter. As
    always, it is critical to check for possible errors by checking the
    status code returned by the call; we do this in the code below too.

      result = sbmldoc.convert(props)
      if (result != LIBSBML_OPERATION_SUCCESS):
          sbmldoc.printErrors()
          raise SystemExit('Conversion failed... ('+ str(result) + ')')

    If successful, we simply write out the resulting flattened model to
    an output file which, for the purposes of this simple example, we
    assume is indicated by the second argument handed to the program on
    the command line by the user.

      writer  = SBMLWriter()
      check(writer, 'create an SBMLWriter object.')
      writer.writeSBML(sbmldoc, output_file)
      print('Flattened model written to %s' % (output_file))

    Example use of the program
    ......................................................................

    What is the result of the above on an actual model?  Suppose we have
    the following SBML Level 3 model stored in a file named
    ''enzyme_model.xml':'

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" level="3" version="1"
            xmlns:comp="http://www.sbml.org/sbml/level3/version1/comp/version1" comp:required="true">

        <model id="aggregate">
          <comp:listOfSubmodels>
            <comp:submodel comp:id="submod1" comp:modelRef="enzyme"/>
            <comp:submodel comp:id="submod2" comp:modelRef="enzyme"/>
          </comp:listOfSubmodels>
        </model>
        <comp:listOfModelDefinitions>
          <comp:modelDefinition id="enzyme" name="enzyme">
            <listOfCompartments>
              <compartment id="compartment" spatialDimensions="3" size="1" constant="true"/>
            </listOfCompartments>
            <listOfSpecies>
              <species id="S"  compartment="compartment" hasOnlySubstanceUnits="false"
                               boundaryCondition="false" constant="false"/>
              <species id="E"  compartment="compartment" hasOnlySubstanceUnits="false" 
                               boundaryCondition="false" constant="false"/>
              <species id="D"  compartment="compartment" hasOnlySubstanceUnits="false" 
                               boundaryCondition="false" constant="false"/>
              <species id="ES" compartment="compartment" hasOnlySubstanceUnits="false"
                               boundaryCondition="false" constant="false"/>
            </listOfSpecies>
            <listOfReactions>
              <reaction id="J0" reversible="true" fast="false">
                <listOfReactants>
                  <speciesReference species="S" stoichiometry="1" constant="true"/>
                  <speciesReference species="E" stoichiometry="1" constant="true"/>
                </listOfReactants>
                <listOfProducts>
                  <speciesReference species="ES" stoichiometry="1" constant="true"/>
                </listOfProducts>
              </reaction>
              <reaction id="J1" reversible="true" fast="false">
                <listOfReactants>
                  <speciesReference species="ES" stoichiometry="1" constant="true"/>
                </listOfReactants>
                <listOfProducts>
                  <speciesReference species="E" stoichiometry="1" constant="true"/>
                  <speciesReference species="D" stoichiometry="1" constant="true"/>
                </listOfProducts>
              </reaction>
            </listOfReactions>
          </comp:modelDefinition>
        </comp:listOfModelDefinitions>
      </sbml>

    Also suppose we have the following SBML Level 3 model stored in a
    file called ''main.xml'' in the same directory as the file above.  The
    model below imports the model ''enzyme'' from the model file above
    twice; this is used to create two submodels whose identifiers are
    ''A'' and ''B'.'

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" level="3" version="1"
            xmlns:comp="http://www.sbml.org/sbml/level3/version1/comp/version1" comp:required="true">
        <model>
          <listOfCompartments>
            <compartment id="compartment" spatialDimensions="3" size="1" constant="true">
              <comp:listOfReplacedElements>
                <comp:replacedElement comp:idRef="compartment" comp:submodelRef="A"/>
                <comp:replacedElement comp:idRef="compartment" comp:submodelRef="B"/>
              </comp:listOfReplacedElements>
            </compartment>
          </listOfCompartments>
          <listOfSpecies>
            <species id="S" compartment="compartment" hasOnlySubstanceUnits="false"
                            boundaryCondition="false" constant="false">
              <comp:listOfReplacedElements>
                <comp:replacedElement comp:idRef="S" comp:submodelRef="A"/>
                <comp:replacedElement comp:idRef="S" comp:submodelRef="B"/>
              </comp:listOfReplacedElements>
            </species>
          </listOfSpecies>
          <comp:listOfSubmodels>
            <comp:submodel comp:id="A" comp:modelRef="ExtMod1"/>
            <comp:submodel comp:id="B" comp:modelRef="ExtMod1"/>
          </comp:listOfSubmodels>
        </model>
        <comp:listOfExternalModelDefinitions>
          <comp:externalModelDefinition comp:id="ExtMod1" comp:source="enzyme_model.xml"
                                        comp:modelRef="enzyme"/>
        </comp:listOfExternalModelDefinitions>
      </sbml>

    Finally, invoking the example program developed the previous section
    on the file ''main.xml',' we would obtain the following XML output as
    result a result

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" level="3" version="1">
        <model>
          <listOfCompartments>
            <compartment id="compartment" spatialDimensions="3" size="1" constant="true"/>
          </listOfCompartments>
          <listOfSpecies>
            <species id="S"     compartment="compartment" hasOnlySubstanceUnits="false"
                                boundaryCondition="false" constant="false"/>
            <species id="A__E"  compartment="compartment" hasOnlySubstanceUnits="false"
                                boundaryCondition="false" constant="false"/>
            <species id="A__D"  compartment="compartment" hasOnlySubstanceUnits="false"
                                boundaryCondition="false" constant="false"/>
            <species id="A__ES" compartment="compartment" hasOnlySubstanceUnits="false"
                                boundaryCondition="false" constant="false"/>
            <species id="B__E"  compartment="compartment" hasOnlySubstanceUnits="false"
                                boundaryCondition="false" constant="false"/>
            <species id="B__D"  compartment="compartment" hasOnlySubstanceUnits="false"
                                boundaryCondition="false" constant="false"/>
            <species id="B__ES" compartment="compartment" hasOnlySubstanceUnits="false"
                                boundaryCondition="false" constant="false"/>
          </listOfSpecies>
          <listOfReactions>
            <reaction id="A__J0" reversible="true" fast="false">
              <listOfReactants>
                <speciesReference species="S" stoichiometry="1" constant="true"/>
                <speciesReference species="A__E" stoichiometry="1" constant="true"/>
              </listOfReactants>
              <listOfProducts>
                <speciesReference species="A__ES" stoichiometry="1" constant="true"/>
              </listOfProducts>
            </reaction>
            <reaction id="A__J1" reversible="true" fast="false">
              <listOfReactants>
                <speciesReference species="A__ES" stoichiometry="1" constant="true"/>
              </listOfReactants>
              <listOfProducts>
                <speciesReference species="A__E" stoichiometry="1" constant="true"/>
                <speciesReference species="A__D" stoichiometry="1" constant="true"/>
              </listOfProducts>
            </reaction>
            <reaction id="B__J0" reversible="true" fast="false">
              <listOfReactants>
                <speciesReference species="S" stoichiometry="1" constant="true"/>
                <speciesReference species="B__E" stoichiometry="1" constant="true"/>
              </listOfReactants>
              <listOfProducts>
                <speciesReference species="B__ES" stoichiometry="1" constant="true"/>
              </listOfProducts>
            </reaction>
            <reaction id="B__J1" reversible="true" fast="false">
              <listOfReactants>
                <speciesReference species="B__ES" stoichiometry="1" constant="true"/>
              </listOfReactants>
              <listOfProducts>
                <speciesReference species="B__E" stoichiometry="1" constant="true"/>
                <speciesReference species="B__D" stoichiometry="1" constant="true"/>
              </listOfProducts>
            </reaction>
          </listOfReactions>
        </model>
      </sbml>

    The final model is a concrete realization of the effective model
    defined by ''main.xml',' with a single compartment and two reactions;
    the species ''S'' can either bind with enzyme ''E'' (from submodel
    ''A')' to form ''D'' (from submodel ''A'),' or with enzyme ''E'' (from
    submodel ''B')' to form ''D'' (from submodel ''B').' In the flattened
    model above, note how the identifiers of components inside the
    ModelDefinition objects ''A'' and ''B'' of our file
    ''enzyme_model.xml'' have been rewritten as (for example) ''A__E''
    ''B__E',' etc.

    General information about the use of SBML converters
    ======================================================================

    The use of all the converters follows a similar approach.  First, one
    creates a ConversionProperties object and calls
    ConversionProperties.addOption() on this object with one argument: a
    text string that identifies the desired converter.  (The text string
    is specific to each converter; consult the documentation for a given
    converter to find out how it should be enabled.)

    Next, for some converters, the caller can optionally set some
    converter-specific properties using additional calls to
    ConversionProperties.addOption(). Many converters provide the ability
    to configure their behavior to some extent; this is realized through
    the use of properties that offer different options.  The default
    property values for each converter can be interrogated using the
    method SBMLConverter.getDefaultProperties() on the converter class in
    question .

    Finally, the caller should invoke the method SBMLDocument.convert()
    with the ConversionProperties object as an argument.

    Example of invoking an SBML converter
    ......................................................................

    The following code fragment illustrates an example using
    SBMLReactionConverter, which is invoked using the option string
    ''replaceReactions':'

      config = ConversionProperties()
      if config != None:
        config.addOption('replaceReactions')

    In the case of SBMLReactionConverter, there are no options to affect
    its behavior, so the next step is simply to invoke the converter on an
    SBMLDocument object.  Continuing the example code:

        # Assume that the variable 'document' has been set to an SBMLDocument object.
        status = document.convert(config)
        if status != LIBSBML_OPERATION_SUCCESS:
          # Handle error somehow.
          print('Error: conversion failed due to the following:')
          document.printErrors()

    Here is an example of using a converter that offers an option. The
    following code invokes SBMLStripPackageConverter to remove the SBML
    Level 3 Layout package from a model.  It sets the name of the package
    to be removed by adding a value for the option named ''package''
    defined by that converter:

      def strip_layout_example(document):
        config = ConversionProperties()
        if config != None:
          config.addOption('stripPackage')
          config.addOption('package', 'layout')
          status = document.convert(config)
          if status != LIBSBML_OPERATION_SUCCESS:
            # Handle error somehow.
            print('Error: unable to strip the Layout package.')
            print('LibSBML returned error: ' + OperationReturnValue_toString(status).strip())
        else:
          # Handle error somehow.
          print('Error: unable to create ConversionProperties object')

    Available SBML converters in libSBML
    ......................................................................

    LibSBML provides a number of built-in converters; by convention, their
    names end in Converter. The following are the built-in converters
    provided by libSBML 5.18.0 :

    @copydetails doc_list_of_libsbml_converters

    """

    __swig_setmethods__ = {}
    for _s in [SBMLConverter]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CompFlatteningConverter, name, value)
    __swig_getmethods__ = {}
    for _s in [SBMLConverter]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CompFlatteningConverter, name)
    __repr__ = _swig_repr

    def init():
        """
        init()


        Internal implementation method.

        """
        return _libsbml.CompFlatteningConverter_init()

    init = staticmethod(init)

    def __init__(self, *args):
        """
        __init__(CompFlatteningConverter self) -> CompFlatteningConverter
        __init__(CompFlatteningConverter self, CompFlatteningConverter orig) -> CompFlatteningConverter


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            CompFlatteningConverter(CompFlatteningConverter orig)

        Copy constructor.

        This creates a copy of a CompFlatteningConverter object.

        Parameter 'orig' is the CompFlatteningConverter instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            CompFlatteningConverter()

        Creates a new CompFlatteningConverter object.

        """
        this = _libsbml.new_CompFlatteningConverter(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(CompFlatteningConverter self) -> CompFlatteningConverter


        Creates and returns a deep copy of this CompFlatteningConverter.

        Returns a (deep) copy of this CompFlatteningConverter.

        """
        return _libsbml.CompFlatteningConverter_clone(self)

    __swig_destroy__ = _libsbml.delete_CompFlatteningConverter
    __del__ = lambda self: None

    def matchesProperties(self, props):
        """
        matchesProperties(CompFlatteningConverter self, ConversionProperties props) -> bool


        Returns 'True' if this converter matches the given properties.

        Given a ConversionProperties object 'props', this method checks that
        'props' possesses an option value to enable the
        CompFlatteningConverter.  If it does, this method returns 'True.'

        Parameter 'props' is the properties to match.

        Returns 'True' if the properties 'props' would match the necessary
        properties for CompFlatteningConverter type of converter, 'False'
        otherwise.

        """
        return _libsbml.CompFlatteningConverter_matchesProperties(self, props)


    def convert(self):
        """
        convert(CompFlatteningConverter self) -> int


        Performs the conversion.

        This method causes CompFlatteningConverter to do the actual conversion
        work, that is, to convert the SBMLDocument object set by
        SBMLConverter.setDocument() and with the configuration options set by
        SBMLConverter.setProperties().

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        """
        return _libsbml.CompFlatteningConverter_convert(self)


    def performConversion(self):
        """
        performConversion(CompFlatteningConverter self) -> int


        Internal implementation method.

        """
        return _libsbml.CompFlatteningConverter_performConversion(self)


    def getDefaultProperties(self):
        """
        getDefaultProperties(CompFlatteningConverter self) -> ConversionProperties


        Returns the default properties of this converter.

        A given converter exposes one or more properties that can be adjusted
        in order to influence the behavior of the converter.  This method
        returns the default property settings for CompFlatteningConverter.  It
        is meant to be called in order to be able to programmatically discover
        all the settings for the converter object.

        CompFlatteningConverter is enabled by creating a ConversionProperties
        object with the option 'flatten comp', and passing this
        ConversionProperties object to SBMLDocument.convert().  The
        CompFlatteningConverter converter accepts numerous options influencing
        its behavior.  The following list briefly summarizes the options:

        * 'flatten comp': Possible values are ''True'' or ''False'.' Setting
        the option to 'True' (the default) means enable the flattening
        converter.

        * 'abortIfUnflattenable': Possible values are ''all','
        ''requiredOnly'' (the default), or ''none'.'  Controls what happens
        upon encountering an SBML Level 3 package with no flattener
        implementation.

        * 'stripUnflattenablePackages': Possible values are ''True'' or
        ''False'' (the default).  Controls whether the constructs of Level 3
        packages with no flattener implementation are stripped from the
        output.

        * 'stripPackages': The value must be a string representing a comma-
        separated list of SBML Level 3 packages to be stripped before
        conversion.  (Default value: empty string, meaning, no packages.)

        * 'basePath': The value must be a string representing the path where
        the converter should search for any ExternalModelDefinition objects.
        (Default value: '.', meaning, the current directory.)

        * 'leavePorts': Possible values are ''True'' or ''False'' (the
        default).  Controls what happens to Port constructs in the output.

        * 'listModelDefinitions': Possible values are ''True'' or ''False''
        (the default).  Controls what happens to ModelDefinition and
        ExternalModelDefinition objects in the final output.

        * 'performValidation': Possible values are ''True'' (the default) or
        ''False'.'  Controls whether whether libSBML validates the model
        before attempting to flatten it. Returns the ConversionProperties
        object describing the default properties for this converter.

        Note: Previously, CompFlatteningConverter also offered an
        'ignorePackages' option, whose name proved to be confusing.  This
        option has been deprecated and replaced by the
        'stripUnflattenablePackages' option.

        """
        return _libsbml.CompFlatteningConverter_getDefaultProperties(self)

CompFlatteningConverter_swigregister = _libsbml.CompFlatteningConverter_swigregister
CompFlatteningConverter_swigregister(CompFlatteningConverter)

def CompFlatteningConverter_init():
    """
    CompFlatteningConverter_init()


    Internal implementation method.

    """
    return _libsbml.CompFlatteningConverter_init()

class CompBase(SBase):
    """

    [SBML 'comp' package]  Convenience class for SBase-derived classes.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    The CompBase class derives from SBase, and defines a few functions
    and features common to all SBase-derived classes in the SBML Level 3
    Hierarchical Model Composition ("comp") package.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CompBase, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CompBase, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_CompBase
    __del__ = lambda self: None

    def getPackageURI(self):
        """
        getPackageURI(CompBase self) -> string


        Returns the XML namespace (URI) of the package extension of this
        object.

        Returns the URI of the package extension of this plugin object.

        """
        return _libsbml.CompBase_getPackageURI(self)


    def getPackageName(self):
        """
        getPackageName(CompBase self) -> string


        Returns the package name of this plugin object.

        Returns the package name of this plugin object.

        """
        return _libsbml.CompBase_getPackageName(self)


    def getPackageVersion(self):
        """
        getPackageVersion(CompBase self) -> unsigned int


        Returns the package version of the package extension of this plugin
        object.

        Returns the package version of the package extension of this plugin
        object.

        """
        return _libsbml.CompBase_getPackageVersion(self)


    def getParentModel(child):
        """
        getParentModel(SBase child) -> Model


        Returns the Model object to which the referenced child object belongs.

        """
        return _libsbml.CompBase_getParentModel(child)

    getParentModel = staticmethod(getParentModel)
CompBase_swigregister = _libsbml.CompBase_swigregister
CompBase_swigregister(CompBase)

def CompBase_getParentModel(child):
    """
    CompBase_getParentModel(SBase child) -> Model


    Returns the Model object to which the referenced child object belongs.

    """
    return _libsbml.CompBase_getParentModel(child)

class SBaseRef(CompBase):
    """

    [SBML 'comp' package]  Base class for references to objects.

    The SBaseRef class was introduced by the SBML Level 3 Hierarchical
    Model Composition ("comp") package as the principle way by which
    submodel elements may be referenced.  The SBaseRef class is usually
    found as the base class of a Port, Deletion, ReplacedElement, or
    ReplacedBy class, but may appear as an child of one of the above
    classes if the parent object references a Submodel.

    An SBaseRef object must reference an element using exactly one of the
    optional attributes of the class.  Subclasses of SBaseRef may define
    additional optional attributes that are legal ways to reference an
    element.

    SBaseRef objects may reference elements that do not live in the Model
    parent  of the SBaseRef object.  However, the SBaseRef class itself
    does not  provide a method of determining which Model or Submodel is
    being referenced. The subclasses of SBaseRef provide methods for this
    instead.

    Once the Model to which the SBaseRef object is referencing has been
    established, there are four optional attributes defined in the
    SBaseRef class that are each methods of referencing an element:

    * 'portRef' (type PortSIdRef):  As its name implies, this
    attribute is used to refer to a port identifier, in the case when the
    reference being constructed with the SBaseRef is intended to refer to
    a port on a submodel.  The namespace of the PortSIdRef value is the
    set of identifiers of type PortSId defined in the submodel, not the
    parent model.

    * 'idRef' (type SIdRef): As its name implies, this attribute is
    used to refer to a regular identifier (i.e., the value of an 'id'
    attribute on some other object), in the case when the reference being
    constructed with the SBaseRef is intended to refer to an object that
    does not have a port identifier.  The namespace of the SIdRef value is
    the set of identifiers of type SId defined in the submodel, not the
    parent model.

    * 'unitRef' (type UnitSIdRef): This attribute is used to refer to
    the identifier of a UnitDefinition object.  The namespace of the
    UnitSIdRef value is the set of unit identifiers defined in the
    submodel, not the parent model. (Note that even though this attribute
    is of type UnitSIdRef, the reserved unit identifiers that are defined
    by SBML Level 3 (see Section 3.1.10 of the core specification) are
    *not* permitted as values of 'unitRef'.  Reserved unit identifiers may
    not be replaced or deleted.)

    * 'metaIdRef' (type IDREF): This attribute is used to refer to a
    'metaid' attribute value on some other object, in the case when the
    reference being constructed with the SBaseRef is intended to refer to
    an object that does not have a port identifier.  The namespace of the
    'metaIdRef' value is the entire document in which the referenced model
    resides, but must refer to a subelement of the referenced model.
    Since meta identifiers are optional attributes of SBase, all SBML
    objects have the potential to have a meta identifier value.

    An SBaseRef object may have up to one subcomponent named 'sBaseRef',
    of type SBaseRef.  This permits recursive structures to be constructed
    so that objects inside submodels can be referenced.

    The form of such recursive references must be as follows.  The
    highest-level SBaseRef object of such a chain (which will necessarily
    be an object of class Port, Deletion, ReplacedElement or ReplacedBy,
    because they are the only classes derived from the class SBaseRef)
    must refer to a Submodel object in the containing model.  All child
    SBaseRef objects in the chain must refer to components inside the
    Model instance to which the Submodel refers.

    """

    __swig_setmethods__ = {}
    for _s in [CompBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SBaseRef, name, value)
    __swig_getmethods__ = {}
    for _s in [CompBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SBaseRef, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(SBaseRef self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> SBaseRef
        __init__(SBaseRef self, unsigned int level, unsigned int version) -> SBaseRef
        __init__(SBaseRef self, unsigned int level) -> SBaseRef
        __init__(SBaseRef self) -> SBaseRef
        __init__(SBaseRef self, CompPkgNamespaces compns) -> SBaseRef
        __init__(SBaseRef self, SBaseRef source) -> SBaseRef


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            SBaseRef(long level      = CompExtension.getDefaultLevel(),
        long version    = CompExtension.getDefaultVersion(), long pkgVersion =
        CompExtension.getDefaultPackageVersion())

        Creates a new SBaseRef with the given level, version, and package
        version.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            SBaseRef(CompPkgNamespaces compns)

        Creates a new SBaseRef with the given CompPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'compns' is the CompPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        ______________________________________________________________________
        Method variant with the following signature:

            SBaseRef(SBaseRef source)

        Copy constructor.

        Parameter 'source' is the instance to copy.

        """
        this = _libsbml.new_SBaseRef(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(SBaseRef self) -> SBaseRef


        Creates and returns a deep copy of this SBaseRef object.

        Returns a (deep) copy of this SBaseRef object.

        """
        return _libsbml.SBaseRef_clone(self)

    __swig_destroy__ = _libsbml.delete_SBaseRef
    __del__ = lambda self: None

    def getElementBySId(self, id):
        """
        getElementBySId(SBaseRef self, string id) -> SBase


        Returns the first child element found that has the given 'id' in the
        model-wide SId namespace, or 'None' if no such object is found.

        Parameter 'id' is string representing the id of the object to find.

        Returns a pointer to the SBase element with the given 'id'.

        """
        return _libsbml.SBaseRef_getElementBySId(self, id)


    def getElementByMetaId(self, metaid):
        """
        getElementByMetaId(SBaseRef self, string metaid) -> SBase


        Returns the first child element it can find with the given 'metaid',
        or itself if it has the given 'metaid', or 'None' if no such object is
        found.

        Parameter 'metaid' is string representing the metaid of the object to
        find.

        Returns a pointer to the SBase element with the given 'metaid'.

        """
        return _libsbml.SBaseRef_getElementByMetaId(self, metaid)


    def getMetaIdRef(self):
        """
        getMetaIdRef(SBaseRef self) -> string


        Returns the value of the 'metaIdRef' attribute of this SBaseRef.

        Returns the value of the 'metaIdRef' attribute of this SBaseRef.

        """
        return _libsbml.SBaseRef_getMetaIdRef(self)


    def isSetMetaIdRef(self):
        """
        isSetMetaIdRef(SBaseRef self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        SBaseRef's 'metaIdRef' attribute has been set.

        Returns 'True' if this SBaseRef's 'metaIdRef' attribute has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.SBaseRef_isSetMetaIdRef(self)


    def setMetaIdRef(self, id):
        """
        setMetaIdRef(SBaseRef self, string id) -> int


        Sets the value of the 'metaIdRef' attribute of this SBaseRef.

        This method fails if the id is not a valid syntax for an IDREF
        (LIBSBML_INVALID_ATTRIBUTE_VALUE), or if the SBaseRef already points
        to an element of the submodel using a different interface
        (LIBSBML_OPERATION_FAILED).  An sBaseRef must use exactly one method
        to point to a submodel element.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.SBaseRef_setMetaIdRef(self, id)


    def unsetMetaIdRef(self):
        """
        unsetMetaIdRef(SBaseRef self) -> int


        Unsets the value of the 'metaIdRef' attribute of this SBaseRef.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.SBaseRef_unsetMetaIdRef(self)


    def getPortRef(self):
        """
        getPortRef(SBaseRef self) -> string


        Returns the value of the 'portRef' attribute of this SBaseRef.

        Returns the value of the 'portRef' attribute of this SBaseRef.

        """
        return _libsbml.SBaseRef_getPortRef(self)


    def isSetPortRef(self):
        """
        isSetPortRef(SBaseRef self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        SBaseRef's 'portRef' attribute has been set.

        Returns 'True' if this SBaseRef's 'portRef' attribute has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.SBaseRef_isSetPortRef(self)


    def setPortRef(self, id):
        """
        setPortRef(SBaseRef self, string id) -> int


        Sets the value of the 'portRef' attribute of this SBaseRef.  Fails if
        the id is not a valid syntax for a PortSIdRef
        (LIBSBML_INVALID_ATTRIBUTE_VALUE), or if the SBaseRef already points
        to an element of the submodel using a different interface
        (LIBSBML_OPERATION_FAILED).  An SBaseRef must use exactly one method
        to point to a submodel element.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.SBaseRef_setPortRef(self, id)


    def unsetPortRef(self):
        """
        unsetPortRef(SBaseRef self) -> int


        Unsets the value of the 'portRef' attribute of this SBaseRef.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.SBaseRef_unsetPortRef(self)


    def getIdRef(self):
        """
        getIdRef(SBaseRef self) -> string


        Returns the value of the 'idRef' attribute of this SBaseRef.

        Returns the value of the 'idRef' attribute of this SBaseRef.

        """
        return _libsbml.SBaseRef_getIdRef(self)


    def isSetIdRef(self):
        """
        isSetIdRef(SBaseRef self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        SBaseRef's 'idRef' attribute has been set.

        Returns 'True' if this SBaseRef's 'idRef' attribute has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.SBaseRef_isSetIdRef(self)


    def setIdRef(self, id):
        """
        setIdRef(SBaseRef self, string id) -> int


        Sets the value of the 'idRef' attribute of this SBaseRef.

        This method fails if the id is not a valid syntax for an SIdRef
        (LIBSBML_INVALID_ATTRIBUTE_VALUE), or if the SBaseRef already points
        to an element of the submodel using a different interface
        (LIBSBML_OPERATION_FAILED).  A sBaseRef must use exactly one method to
        point to a submodel element.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.SBaseRef_setIdRef(self, id)


    def unsetIdRef(self):
        """
        unsetIdRef(SBaseRef self) -> int


        Unsets the value of the 'idRef' attribute of this SBaseRef.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.SBaseRef_unsetIdRef(self)


    def getUnitRef(self):
        """
        getUnitRef(SBaseRef self) -> string


        Returns the value of the 'unitRef' attribute of this SBaseRef.

        Returns the value of the 'unitRef' attribute of this SBaseRef.

        """
        return _libsbml.SBaseRef_getUnitRef(self)


    def isSetUnitRef(self):
        """
        isSetUnitRef(SBaseRef self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        SBaseRef's 'unitRef' attribute has been set.

        Returns 'True' if this SBaseRef's 'unitRef' attribute has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.SBaseRef_isSetUnitRef(self)


    def setUnitRef(self, id):
        """
        setUnitRef(SBaseRef self, string id) -> int


        Sets the value of the 'unitRef' attribute of this SBaseRef.

        This method fails if the id is not a valid syntax for a UnitSIdRef
        (LIBSBML_INVALID_ATTRIBUTE_VALUE), or if the SBaseRef already points
        to an element of the submodel using a different interface
        (LIBSBML_OPERATION_FAILED).  A sBaseRef must use exactly one method to
        point to a submodel element.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.SBaseRef_setUnitRef(self, id)


    def unsetUnitRef(self):
        """
        unsetUnitRef(SBaseRef self) -> int


        Unsets the value of the 'unitRef' attribute of this SBaseRef.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.SBaseRef_unsetUnitRef(self)


    def getSBaseRef(self, *args):
        """
        getSBaseRef(SBaseRef self) -> SBaseRef
        getSBaseRef(SBaseRef self) -> SBaseRef


        Get the child sBaseRef of this sBaseRef.

        Returns the  SBaseRef child of this SBaseRef, or 'None' if none
        exists.

        """
        return _libsbml.SBaseRef_getSBaseRef(self, *args)


    def isSetSBaseRef(self):
        """
        isSetSBaseRef(SBaseRef self) -> bool


        Predicate for testing whether the sBaseRef for this SBaseRef is set.

        Returns 'True' if the sBaseRef of this SBaseRef is set, 'False'
        otherwise.

        """
        return _libsbml.SBaseRef_isSetSBaseRef(self)


    def setSBaseRef(self, sBaseRef):
        """
        setSBaseRef(SBaseRef self, SBaseRef sBaseRef) -> int


        Sets the sBaseRef definition of this SBaseRef to a copy of the given
        SBaseRef object instance.

        This method fails if the added sBaseRef does not match the
        level/version/package of the parent object or if the added sBaseRef
        cannot be copied.

        Parameter 'sBaseRef' is the SBaseRef object instance to use.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_PKG_VERSION_MISMATCH

        """
        return _libsbml.SBaseRef_setSBaseRef(self, sBaseRef)


    def createSBaseRef(self):
        """
        createSBaseRef(SBaseRef self) -> SBaseRef


        Creates a new, empty SBaseRef, adds it to this SBaseRef and  returns
        the created SBaseRef.

        Returns the newly created SBaseRef object instance.

        """
        return _libsbml.SBaseRef_createSBaseRef(self)


    def unsetSBaseRef(self):
        """
        unsetSBaseRef(SBaseRef self) -> int


        Unsets the child SBaseRef of this SBaseRef.  Deletes the former
        SBaseRef child, if one existed.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.SBaseRef_unsetSBaseRef(self)


    def getNumReferents(self):
        """
        getNumReferents(SBaseRef self) -> int


        Returns how many elements are being referred to by this SBaseRef.  A
        valid SBaseRef will have exactly one.  Possible referents are portRef,
        idRef, unitRef, and metaIdRef.

        Returns integer value between 0 and 4: the number of different ways
        this element points to its referent.

        """
        return _libsbml.SBaseRef_getNumReferents(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(SBaseRef self) -> bool


        Returns 'True' if getNumReferents() is exactly 1.

        Returns boolean: 'true' if the attributes are correctly set; 'false'
        if not.

        """
        return _libsbml.SBaseRef_hasRequiredAttributes(self)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(SBaseRef self, string oldid, string newid)


        Replaces all uses of a given 'SIdRef' type attribute value with
        another value.

        In SBML, object identifiers are of a data type called SId. In SBML
        Level 3, an explicit data type called SIdRef was introduced for
        attribute values that refer to SId values; in previous Levels of SBML,
        this data type did not exist and attributes were simply described to
        as 'referring to an identifier', but the effective data type was the
        same as SIdRef in Level 3.  These and other methods of libSBML refer
        to the type SIdRef for all Levels of SBML, even if the corresponding
        SBML specification did not explicitly name the data type.

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas in MathML content, comparing the referenced
        identifiers to the value of 'oldid'.  If any matches are found, the
        matching values are replaced with 'newid'.  The method does not
        descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.SBaseRef_renameSIdRefs(self, oldid, newid)


    def getElementName(self):
        """
        getElementName(SBaseRef self) -> string


        Returns the XML element name of this SBML object.

        Returns the name of this element, as a text string.

        """
        return _libsbml.SBaseRef_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(SBaseRef self) -> int


        Returns the libSBML type code of this object instance.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_COMP_SBASEREF.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.SBaseRef_getTypeCode(self)


    def connectToChild(self):
        """connectToChild(SBaseRef self)"""
        return _libsbml.SBaseRef_connectToChild(self)


    def getReferencedElementFrom(self, model):
        """
        getReferencedElementFrom(SBaseRef self, Model model) -> SBase


        Examines the referenced Model for the referenced object, and returns
        it, if found.

        Parameter 'model' is the Model in which to look for the object
        referenced by this SBaseRef.

        Returns the element in the referenced Model to which this SBaseRef
        refers.  If this object references an object in a Submodel, the
        returned object will be in the instantiated Model in that Submodel.

        """
        return _libsbml.SBaseRef_getReferencedElementFrom(self, model)


    def saveReferencedElement(self):
        """
        saveReferencedElement(SBaseRef self) -> int


        Finds and stores the referenced object by finding the Model it needs
        to point to, calling 'saveReferencedElement' on its parent (which will
        also be a SBaseRef or one of its subclasses), and the storing the
        result.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.SBaseRef_saveReferencedElement(self)


    def getReferencedElement(self):
        """
        getReferencedElement(SBaseRef self) -> SBase


        Returns the object pointed to by this element.  If that element was
        previously found and set with 'saveReferencedElement', that element is
        returned; otherwise, 'saveReferencedElement' is called first, and the
        found element is returned.

        """
        return _libsbml.SBaseRef_getReferencedElement(self)


    def clearReferencedElement(self):
        """
        clearReferencedElement(SBaseRef self)


        Removes the saved referenced element, if it had been saved earlier.

        """
        return _libsbml.SBaseRef_clearReferencedElement(self)


    def performDeletion(self):
        """
        performDeletion(SBaseRef self) -> int


        DEPRECATED FUNCTION:  DO NOT USE

        Deletes the referenced object, plus any other elements that element
        points to through ReplacedElement or ReplacedBy children.  Instead of
        calling this function directly, use
        'CompModelPlugin::instantiateSubmodels' instead, which deals with all
        the intricacies of replacements and deletions, and gives you access to
        the non-flattened hierarchical form of the model.

        """
        return _libsbml.SBaseRef_performDeletion(self)


    def removeFromParentAndDelete(self):
        """
        removeFromParentAndDelete(SBaseRef self) -> int


        Finds this SBaseRef's parent, which can either be a List or can be
        another SBaseRef, and tells it to remove this.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.SBaseRef_removeFromParentAndDelete(self)

SBaseRef_swigregister = _libsbml.SBaseRef_swigregister
SBaseRef_swigregister(SBaseRef)

class Replacing(SBaseRef):
    """

    [SBML 'comp' package]  Convenience class.

    The Replacing class does not exist officialy in the the Hierarchical
    Model Composition ("comp") package, but is implemented here as a
    convenience subclass of the ReplacedElement and ReplacedBy classes,
    since both of those classes define a 'submodelRef' attribute.

    The required attribute 'submodelRef' takes a value of type SIdRef,
    which must be the identifier of a Submodel object in the containing
    model.  The model referenced by the Submodel object establishes the
    object namespaces for the 'portRef', 'idRef', 'unitRef' and
    'metaIdRef' attributes: only objects within the Model object may be
    referenced by those attributes.

    """

    __swig_setmethods__ = {}
    for _s in [SBaseRef]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Replacing, name, value)
    __swig_getmethods__ = {}
    for _s in [SBaseRef]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Replacing, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_Replacing
    __del__ = lambda self: None

    def getSubmodelRef(self):
        """
        getSubmodelRef(Replacing self) -> string


        Returns the value of the 'submodelRef' attribute of this SBaseRef.

        Returns the value of the 'submodelRef' attribute of this SBaseRef.

        """
        return _libsbml.Replacing_getSubmodelRef(self)


    def isSetSubmodelRef(self):
        """
        isSetSubmodelRef(Replacing self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        SBaseRef's 'submodelRef' attribute has been set.

        Returns 'True' if this SBaseRef's 'submodelRef' attribute has been
        set,  otherwise 'False' is returned.

        """
        return _libsbml.Replacing_isSetSubmodelRef(self)


    def setSubmodelRef(self, id):
        """
        setSubmodelRef(Replacing self, string id) -> int


        Sets the value of the 'submodelRef' attribute of this SBaseRef.  Fails
        if the id is not a valid syntax for an SIdRef.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Replacing_setSubmodelRef(self, id)


    def unsetSubmodelRef(self):
        """
        unsetSubmodelRef(Replacing self) -> int


        Unsets the value of the 'SubmodelRef' attribute of this SBaseRef.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Replacing_unsetSubmodelRef(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(Replacing self) -> bool


        Returns 'True' if getNumReferents() is exactly 1 and if the
        submodelRef is set.

        Returns boolean: 'true' if the attributes are correctly set; 'false'
        if not.

        """
        return _libsbml.Replacing_hasRequiredAttributes(self)


    def saveReferencedElement(self):
        """
        saveReferencedElement(Replacing self) -> int


        Finds and stores the referenced object.  Finds the Submodel to which
        it refers, getting the instantiated Model inside that Submodel,
        calling 'getReferencedElementFrom' on that model, and storing the
        result.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Replacing_saveReferencedElement(self)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(Replacing self, string oldid, string newid)


        Replaces all uses of a given 'SIdRef' type attribute value with
        another value.

        In SBML, object identifiers are of a data type called SId. In SBML
        Level 3, an explicit data type called SIdRef was introduced for
        attribute values that refer to SId values; in previous Levels of SBML,
        this data type did not exist and attributes were simply described to
        as 'referring to an identifier', but the effective data type was the
        same as SIdRef in Level 3.  These and other methods of libSBML refer
        to the type SIdRef for all Levels of SBML, even if the corresponding
        SBML specification did not explicitly name the data type.

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas in MathML content, comparing the referenced
        identifiers to the value of 'oldid'.  If any matches are found, the
        matching values are replaced with 'newid'.  The method does not
        descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.Replacing_renameSIdRefs(self, oldid, newid)


    def performReplacement(self):
        """
        performReplacement(Replacing self) -> int


        DEPRECATED FUNCTION:  DO NOT USE

        To retain old functionality, this function calls
        performReplacementAndCollect, and then actually removes the now-
        redundant element.  However, this can lead to doubly-deleted elements,
        as well as the incorrect interpretation of some models.  The
        replacement function performReplacementAndCollect has been marked
        protected, in the hopes that people will instead simply use
        CompModelPlugin::instantiateSubmodels, which hides all the complexity
        while still allowing access to a non-flattened version of a
        hierarchical model.

        """
        return _libsbml.Replacing_performReplacement(self)


    def replaceWithAndMaybeDelete(self, replacement, deleteme, conversionFactor):
        """
        replaceWithAndMaybeDelete(Replacing self, SBase replacement, bool deleteme, ASTNode conversionFactor) -> int


        Internal implementation method.

        """
        return _libsbml.Replacing_replaceWithAndMaybeDelete(self, replacement, deleteme, conversionFactor)

Replacing_swigregister = _libsbml.Replacing_swigregister
Replacing_swigregister(Replacing)

class Deletion(SBaseRef):
    """

    [SBML 'comp' package]  Deletion of an object from a submodel.

    The Deletion class was introduced by the SBML Level 3 Hierarchical
    Model Composition ("comp") package to allow elements of submodels to
    be removed before instantiation. The Deletion object class is used to
    define a deletion operation to be applied when a submodel instantiates
    a model definition. Deletions may be useful in hierarchical model
    composition scenarios for various reasons.  For example, some
    components in a submodel may be redundant in the composed model,
    perhaps because the same features are implemented in a different way
    in the new model. Deletions function as follows.  When the Model to
    which the Submodel object refers (via the 'modelRef' attribute) is
    read and processed for inclusion into the composed model, each
    Deletion object identifies an object to remove from that Model
    instance.  The resulting submodel instance consists of everything in
    the Model object instance minus the entities referenced by the list of
    Deletion objects.

    As might be expected, deletions can have wide-ranging implications,
    especially when the object deleted has substantial substructure, as in
    the case of reactions.  The following are rules regarding deletions
    and their effects.

    * An object that has been deleted is considered inaccessible. Any
    element that has been deleted (or replaced) may not be referenced by
    an SBaseRef object.

    * If the deleted object has child objects and other structures, the
    child objects and substructure are also considered to be deleted.

    * It is not an error to delete explicitly an object that is already
    deleted by implication (for example as a result of the second point
    above).  The resulting model is the same.

    * If the deleted object is from an SBML namespace that is not
    understood by the interpreter, the deletion must be ignored---the
    object will not need to be deleted, as the interpreter could not
    understand the package.  If an interpreter cannot tell whether  a
    referenced object does not exist or if exists in an unparsed namespace
    it may produce a warning.

    The Deletion object class is subclassed from SBaseRef, and reuses all
    the  machinery provided by SBaseRef.  In addition, it defines two
    optional  attributes, 'id' and 'name'.  The 'id' attribute can be used
    to give an identifier to a given deletion operation.  The identifier
    has no mathematical meaning, but it may be useful for creating
    submodels that can be manipulated more directly by other submodels.
    (Indeed, it is legitimate for an enclosing model definition to delete
    a deletion!)

    The optional 'name' attribute is provided on Deletion for the same
    reason it is provided on other elements that have identifiers; viz.,
    to provide for the possibility of giving a human-readable name to the
    object.  The name may be useful in situations when deletions are
    displayed to modelers.

    """

    __swig_setmethods__ = {}
    for _s in [SBaseRef]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Deletion, name, value)
    __swig_getmethods__ = {}
    for _s in [SBaseRef]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Deletion, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(Deletion self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> Deletion
        __init__(Deletion self, unsigned int level, unsigned int version) -> Deletion
        __init__(Deletion self, unsigned int level) -> Deletion
        __init__(Deletion self) -> Deletion
        __init__(Deletion self, CompPkgNamespaces compns) -> Deletion
        __init__(Deletion self, Deletion source) -> Deletion


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            Deletion(Deletion source)

        Copy constructor.

        Parameter 'source' is the Deletion instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            Deletion(long level      = CompExtension.getDefaultLevel(),
        long version    = CompExtension.getDefaultVersion(), long pkgVersion =
        CompExtension.getDefaultPackageVersion())

        Creates a new Deletion with the given level, version, and package
        version.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            Deletion(CompPkgNamespaces compns)

        Creates a new Deletion with the given CompPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'compns' is the CompPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_Deletion(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(Deletion self) -> Deletion


        Creates and returns a deep copy of this Deletion object.

        Returns a (deep) copy of this Deletion object.

        """
        return _libsbml.Deletion_clone(self)

    __swig_destroy__ = _libsbml.delete_Deletion
    __del__ = lambda self: None

    def setId(self, sid):
        """
        setId(Deletion self, string sid) -> int


        Sets the value of the 'id' attribute of this Deletion.

        The string 'sid' is copied.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Parameter 'sid' is the string to use as the identifier of this object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.Deletion_setId(self, sid)


    def getId(self):
        """
        getId(Deletion self) -> string


        Returns the value of the 'id' attribute of this Deletion.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is now recommended to use the
        getIdAttribute() function instead.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns the id of this Deletion.

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.Deletion_getId(self)


    def isSetId(self):
        """
        isSetId(Deletion self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        object's 'id' attribute has been set.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns 'True' if the 'id' attribute of this SBML object is set,
        'False' otherwise.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is recommended that callers use
        isSetIdAttribute() instead.

        See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(),
        isSetIdAttribute().

        """
        return _libsbml.Deletion_isSetId(self)


    def unsetId(self):
        """
        unsetId(Deletion self) -> int


        Unsets the value of the 'id' attribute of this Deletion.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.Deletion_unsetId(self)


    def setName(self, name):
        """
        setName(Deletion self, string name) -> int


        Sets the value of the 'name' attribute of this Deletion.

        The string in 'name' is copied.

        Parameter 'name' is the new name for the SBML object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Deletion_setName(self, name)


    def getName(self):
        """
        getName(Deletion self) -> string


        Returns the value of the 'name' attribute of this Deletion object.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns the name of this SBML object, or the empty string if not set
        or unsettable.

        See also getIdAttribute(), isSetName(), setName(), unsetName().

        """
        return _libsbml.Deletion_getName(self)


    def isSetName(self):
        """
        isSetName(Deletion self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        object's 'name' attribute has been set.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns 'True' if the 'name' attribute of this SBML object is set,
        'False' otherwise.

        See also getName(), setName(), unsetName().

        """
        return _libsbml.Deletion_isSetName(self)


    def unsetName(self):
        """
        unsetName(Deletion self) -> int


        Unsets the value of the 'name' attribute of this Deletion.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getName(), setName(), isSetName().

        """
        return _libsbml.Deletion_unsetName(self)


    def getElementName(self):
        """
        getElementName(Deletion self) -> string


        Returns the XML element name of this SBML object.

        Returns the name of this element, as a text string.

        """
        return _libsbml.Deletion_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(Deletion self) -> int


        Returns the libSBML type code of this object instance.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_COMP_DELETION.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.Deletion_getTypeCode(self)


    def saveReferencedElement(self):
        """
        saveReferencedElement(Deletion self) -> int


        Finds and stores the referenced object.  It finds its Submodel parent,
        gets its instantiated Model object, calls 'getReferencedElementFrom()'
        using that model, and stores the result.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Deletion_saveReferencedElement(self)

Deletion_swigregister = _libsbml.Deletion_swigregister
Deletion_swigregister(Deletion)

class ExternalModelDefinition(CompBase):
    """

    [SBML 'comp' package]  A reference to an externally-defined model.

    The ExternalModelDefinition class was introduced by the SBML Level 3
    Hierarchical Model Composition ("comp") package to define references
    to Model objects defined in other files.

    ExternalModelDefinition objects are model definitions---in and of
    themselves, they are definitions of models but not uses of those
    models. The class provides a way to declare and identify them so that
    Model objects in the present SBML document can use them in Submodel
    objects.

    ExternalModelDefinition contains two required attributes ('source' and
    'id') and three optional attributes ('modelRef', 'md5' and 'name').

    The 'id' attribute serves to provide a handle for the external model
    reference so that Submodel objects can refer to it.  Crucially, it is
    not the identifier of the model being referenced; rather, it is an
    identifier for this ExternalModelDefinition object within the current
    SBML document.  The 'id' attribute takes a required value of type SId,
    and must be unique across all Model and ExternalModelDefinition
    objects present in the document.

    ExternalModelDefinition also has an optional 'name' attribute, of type
    'string'.  The 'name' attribute may be used to provide a human-
    readable description of the ExternalModelDefintion object.

    The required attribute 'source' is used to locate the SBML document
    containing an external model definition.  The value of this attribute
    must be of type anyURI.  Since URIs may be either URLs, URNs, or
    relative or absolute file locations, this offers flexibility in
    referencing SBML documents.  In all cases, the 'source' attribute
    value must refer specifically to an SBML Level 3 document; prior
    Levels/Versions of SBML are not supported by this package.  The entire
    file at the given location is referenced.  The 'source' attribute must
    have a value for every ExternalModelDefinition instance.

    It should be noted that even though there is currently only a
    Hierarchical Model Composition package for SBML Level 3 Version 1, it
    may be used in SBML Level 3 Version 2, as long as nothing new from
    that package is used.  This allows the ExternalModelDefinition to
    reference any SBML Level 3 document, so long as only constructs from
    Version 1 are used.

    ExternalModelDefinition's optional attribute 'modelRef', of type
    SIdRef, is used to identify a Model or ExternalModelDefinition object
    within the SBML document located at 'source'.  The object referenced
    may be the main model in the document, or it may be a model definition
    contained in the SBML document's ListOfModelDefinitions or
    ListOfExternalModelDefinitions lists.  Loops are not allowed: it must
    be possible to follow a chain of ExternalModelDefinition objects to
    its end in a Model object.

    In core SBML, the 'id' on Model is an optional attribute, and
    therefore, it is possible that the Model object in a given SBML
    document does not have an identifier.  In that case, there is no value
    to give to the 'modelRef' attribute in ExternalModelDefinition.  If
    'modelRef' does not have a value, then the main model (i.e., the
    <model> element within the <sbml> element) in the referenced file is
    interpreted as being the model referenced by this
    ExternalModelDefinition instance.

    Finally, the optional 'md5' attribute takes a string value.  If set,
    it must be an MD5 checksum value computed over the document referenced
    by 'source'.  This checksum can serve as a data integrity check over
    the contents of the 'source'.  Applications may use this to verify
    that the contents have not changed since the time that the
    ExternalModelDefinition reference was constructed.

    """

    __swig_setmethods__ = {}
    for _s in [CompBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ExternalModelDefinition, name, value)
    __swig_getmethods__ = {}
    for _s in [CompBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ExternalModelDefinition, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ExternalModelDefinition self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ExternalModelDefinition
        __init__(ExternalModelDefinition self, unsigned int level, unsigned int version) -> ExternalModelDefinition
        __init__(ExternalModelDefinition self, unsigned int level) -> ExternalModelDefinition
        __init__(ExternalModelDefinition self) -> ExternalModelDefinition
        __init__(ExternalModelDefinition self, CompPkgNamespaces compns) -> ExternalModelDefinition
        __init__(ExternalModelDefinition self, ExternalModelDefinition source) -> ExternalModelDefinition


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ExternalModelDefinition(long level      =
        CompExtension.getDefaultLevel(), long version    =
        CompExtension.getDefaultVersion(), long pkgVersion =
        CompExtension.getDefaultPackageVersion())

        Creates a new ExternalModelDefinition with the given level, version,
        and package version.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            ExternalModelDefinition(CompPkgNamespaces compns)

        Creates a new ExternalModelDefinition with the given CompPkgNamespaces
        object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'compns' is the CompPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        ______________________________________________________________________
        Method variant with the following signature:

            ExternalModelDefinition(ExternalModelDefinition source)

        Copy constructor.

        Parameter 'source' is the object to copy.

        """
        this = _libsbml.new_ExternalModelDefinition(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ExternalModelDefinition self) -> ExternalModelDefinition


        Creates and returns a deep copy of this ExternalModelDefinition
        object.

        Returns a (deep) copy of this ExternalModelDefinition object.

        """
        return _libsbml.ExternalModelDefinition_clone(self)

    __swig_destroy__ = _libsbml.delete_ExternalModelDefinition
    __del__ = lambda self: None

    def setId(self, sid):
        """
        setId(ExternalModelDefinition self, string sid) -> int


        Sets the value of the 'id' attribute of this ExternalModelDefinition.

        The string 'sid' is copied.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Parameter 'sid' is the string to use as the identifier of this object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.ExternalModelDefinition_setId(self, sid)


    def getId(self):
        """
        getId(ExternalModelDefinition self) -> string


        Returns the value of the 'id' attribute of this
        ExternalModelDefinition.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is now recommended to use the
        getIdAttribute() function instead.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns the id of this ExternalModelDefinition.

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.ExternalModelDefinition_getId(self)


    def isSetId(self):
        """
        isSetId(ExternalModelDefinition self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        object's 'id' attribute has been set.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns 'True' if the 'id' attribute of this SBML object is set,
        'False' otherwise.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is recommended that callers use
        isSetIdAttribute() instead.

        See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(),
        isSetIdAttribute().

        """
        return _libsbml.ExternalModelDefinition_isSetId(self)


    def unsetId(self):
        """
        unsetId(ExternalModelDefinition self) -> int


        Unsets the value of the 'id' attribute of this
        ExternalModelDefinition.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.ExternalModelDefinition_unsetId(self)


    def setName(self, name):
        """
        setName(ExternalModelDefinition self, string name) -> int


        Sets the value of the 'name' attribute of this
        ExternalModelDefinition.

        The string in 'name' is copied.

        Parameter 'name' is the new name for the SBML object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.ExternalModelDefinition_setName(self, name)


    def getName(self):
        """
        getName(ExternalModelDefinition self) -> string


        Returns the value of the 'name' attribute of this
        ExternalModelDefinition object.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns the name of this SBML object, or the empty string if not set
        or unsettable.

        See also getIdAttribute(), isSetName(), setName(), unsetName().

        """
        return _libsbml.ExternalModelDefinition_getName(self)


    def isSetName(self):
        """
        isSetName(ExternalModelDefinition self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        object's 'name' attribute has been set.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns 'True' if the 'name' attribute of this SBML object is set,
        'False' otherwise.

        See also getName(), setName(), unsetName().

        """
        return _libsbml.ExternalModelDefinition_isSetName(self)


    def unsetName(self):
        """
        unsetName(ExternalModelDefinition self) -> int


        Unsets the value of the 'name' attribute of this
        ExternalModelDefinition.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getName(), setName(), isSetName().

        """
        return _libsbml.ExternalModelDefinition_unsetName(self)


    def getModelRef(self):
        """
        getModelRef(ExternalModelDefinition self) -> string


        Returns the value of the 'modelRef' attribute of this
        ExternalModelDefinition.

        Returns the value of the 'modelRef' attribute of this
        ExternalModelDefinition.

        """
        return _libsbml.ExternalModelDefinition_getModelRef(self)


    def isSetModelRef(self):
        """
        isSetModelRef(ExternalModelDefinition self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        ExternalModelDefinition's 'modelRef' attribute has been set.

        Returns 'True' if this ExternalModelDefinition's 'modelRef' attribute
        has been set, otherwise 'False' is returned.

        """
        return _libsbml.ExternalModelDefinition_isSetModelRef(self)


    def setModelRef(self, id):
        """
        setModelRef(ExternalModelDefinition self, string id) -> int


        Sets the value of the 'modelRef' attribute of this
        ExternalModelDefinition.  Fails if the 'id' is not a valid syntax for
        an SIdRef.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.ExternalModelDefinition_setModelRef(self, id)


    def unsetModelRef(self):
        """
        unsetModelRef(ExternalModelDefinition self) -> int


        Unsets the value of the 'modelRef' attribute of this
        ExternalModelDefinition.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.ExternalModelDefinition_unsetModelRef(self)


    def getMd5(self):
        """
        getMd5(ExternalModelDefinition self) -> string


        Returns the value of the 'md5' attribute of this
        ExternalModelDefinition.

        Returns the value of the 'md5' attribute of this
        ExternalModelDefinition.

        """
        return _libsbml.ExternalModelDefinition_getMd5(self)


    def isSetMd5(self):
        """
        isSetMd5(ExternalModelDefinition self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        ExternalModelDefinition's 'md5' attribute has been set.

        Returns 'True' if this ExternalModelDefinition's 'md5' attribute has
        been set, otherwise 'False' is returned.

        """
        return _libsbml.ExternalModelDefinition_isSetMd5(self)


    def setMd5(self, md5):
        """
        setMd5(ExternalModelDefinition self, string md5) -> int


        Sets the value of the 'md5' attribute of this ExternalModelDefinition.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.ExternalModelDefinition_setMd5(self, md5)


    def unsetMd5(self):
        """
        unsetMd5(ExternalModelDefinition self) -> int


        Unsets the value of the 'md5' attribute of this
        ExternalModelDefinition.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.ExternalModelDefinition_unsetMd5(self)


    def getSource(self):
        """
        getSource(ExternalModelDefinition self) -> string


        Returns the value of the 'source' attribute of this
        ExternalModelDefinition.

        Returns the value of the 'source' attribute of this
        ExternalModelDefinition.

        """
        return _libsbml.ExternalModelDefinition_getSource(self)


    def isSetSource(self):
        """
        isSetSource(ExternalModelDefinition self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        ExternalModelDefinition's 'source' attribute has been set.

        Returns 'True' if this ExternalModelDefinition's 'source' attribute
        has been set, otherwise 'False' is returned.

        """
        return _libsbml.ExternalModelDefinition_isSetSource(self)


    def setSource(self, source):
        """
        setSource(ExternalModelDefinition self, string source) -> int


        Sets the value of the 'source' attribute of this
        ExternalModelDefinition.

        Parameter 'source' is the value to use for the 'source' attribute.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.ExternalModelDefinition_setSource(self, source)


    def unsetSource(self):
        """
        unsetSource(ExternalModelDefinition self) -> int


        Unsets the value of the 'source' attribute of this
        ExternalModelDefinition.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.ExternalModelDefinition_unsetSource(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(ExternalModelDefinition self) -> bool


        Returns 'True' if the 'modelRef' and 'id' attributes are set, and
        'False' if not.

        This method does not check to see if the referred-to model actually
        exists.

        Returns boolean: 'True' if the attributes are correctly set; 'False'
        if not.

        """
        return _libsbml.ExternalModelDefinition_hasRequiredAttributes(self)


    def getElementName(self):
        """
        getElementName(ExternalModelDefinition self) -> string


        Returns the XML element name of this SBML object.

        Returns the name of this element, as a text string.

        """
        return _libsbml.ExternalModelDefinition_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(ExternalModelDefinition self) -> int


        Returns the libSBML type code of this object instance.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object:
        SBML_COMP_EXTERNALMODELDEFINITION.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ExternalModelDefinition_getTypeCode(self)


    def getReferencedModel(self):
        """getReferencedModel(ExternalModelDefinition self) -> Model"""
        return _libsbml.ExternalModelDefinition_getReferencedModel(self)

ExternalModelDefinition_swigregister = _libsbml.ExternalModelDefinition_swigregister
ExternalModelDefinition_swigregister(ExternalModelDefinition)

class ListOfDeletions(ListOf):
    """

    [SBML 'comp' package]  A list of Deletion objects.

    The ListOfDeletions is a container for the "comp" Submodel that
    defines elements to be removed before instantiation.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    See also Deletion, ListOfExternalModelDefinitions,
    ListOfModelDefinitions, ListOfPorts, ListOfReplacedElements,
    ListOfSubmodels.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfDeletions, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfDeletions, name)
    __repr__ = _swig_repr

    def clone(self):
        """
        clone(ListOfDeletions self) -> ListOfDeletions


        Creates and returns a deep copy of this ListOfDeletions object.

        Returns a (deep) copy of this ListOfDeletions.

        """
        return _libsbml.ListOfDeletions_clone(self)


    def __init__(self, *args):
        """
        __init__(ListOfDeletions self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ListOfDeletions
        __init__(ListOfDeletions self, unsigned int level, unsigned int version) -> ListOfDeletions
        __init__(ListOfDeletions self, unsigned int level) -> ListOfDeletions
        __init__(ListOfDeletions self) -> ListOfDeletions
        __init__(ListOfDeletions self, CompPkgNamespaces compns) -> ListOfDeletions


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfDeletions(long level      =
        CompExtension.getDefaultLevel(), long version    =
        CompExtension.getDefaultVersion(), long pkgVersion =
        CompExtension.getDefaultPackageVersion())

        Creates a new ListOfDeletions with the given level, version, and
        package version.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfDeletions(CompPkgNamespaces compns)

        Creates a new ListOfDeletions with the given CompPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'compns' is the CompPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_ListOfDeletions(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def get(self, *args):
        """
        get(ListOfDeletions self, unsigned int n) -> Deletion
        get(ListOfDeletions self, unsigned int n) -> Deletion
        get(ListOfDeletions self, string sid) -> Deletion
        get(ListOfDeletions self, string sid) -> Deletion


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a Deletion from the ListOfDeletions.

        Parameter 'n' is the index number of the Deletion to get.

        Returns the nth Deletion in this ListOfDeletions. If the index 'n' is
        invalid, 'None' is returned.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a Deletion from the ListOfDeletions based on its identifier.

        Parameter 'sid' is a string representing the identifier  of the
        Deletion to get.

        Returns Deletion in this ListOfDeletions with the given 'sid' or
        'None' if no such Deletion exists.

        See also get(), size().

        """
        return _libsbml.ListOfDeletions_get(self, *args)


    def remove(self, *args):
        """
        remove(ListOfDeletions self, unsigned int n) -> Deletion
        remove(ListOfDeletions self, string sid) -> Deletion


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth item from this ListOfDeletions items and returns a
        pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the item to remove.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes an item from this ListOfDeletions items based on its
        identifier and returns a pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'sid' is string representing the id of the item to remove.

        See also size().

        """
        return _libsbml.ListOfDeletions_remove(self, *args)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfDeletions self) -> int


        Returns the libSBML type code for the objects contained in this ListOf
        (i.e., Deletion objects, if the list is non-empty).

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for objects contained in this list:
        SBML_COMP_DELETION (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfDeletions_getItemTypeCode(self)


    def getElementName(self):
        """
        getElementName(ListOfDeletions self) -> string


        Returns the XML element name of this SBML object.

        Returns the name of this element, as a text string.

        """
        return _libsbml.ListOfDeletions_getElementName(self)

    __swig_destroy__ = _libsbml.delete_ListOfDeletions
    __del__ = lambda self: None
ListOfDeletions_swigregister = _libsbml.ListOfDeletions_swigregister
ListOfDeletions_swigregister(ListOfDeletions)

class ListOfExternalModelDefinitions(ListOf):
    """

    [SBML 'comp' package]  A list of ExternalModelDefinition objects.

    The ListOfExternalModelDefinitions is a container for the extended
    SBMLDocument that defines references to Models defined in external
    files.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    See also ExternalModelDefinition, ListOfDeletions,
    ListOfModelDefinitions, ListOfPorts, ListOfReplacedElements,
    ListOfSubmodels.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfExternalModelDefinitions, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfExternalModelDefinitions, name)
    __repr__ = _swig_repr

    def clone(self):
        """
        clone(ListOfExternalModelDefinitions self) -> ListOfExternalModelDefinitions


        Creates and returns a deep copy of this ListOfExternalModelDefinitions
        object.

        Returns a (deep) copy of this ListOfExternalModelDefinitions.

        """
        return _libsbml.ListOfExternalModelDefinitions_clone(self)


    def __init__(self, *args):
        """
        __init__(ListOfExternalModelDefinitions self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ListOfExternalModelDefinitions
        __init__(ListOfExternalModelDefinitions self, unsigned int level, unsigned int version) -> ListOfExternalModelDefinitions
        __init__(ListOfExternalModelDefinitions self, unsigned int level) -> ListOfExternalModelDefinitions
        __init__(ListOfExternalModelDefinitions self) -> ListOfExternalModelDefinitions
        __init__(ListOfExternalModelDefinitions self, CompPkgNamespaces compns) -> ListOfExternalModelDefinitions


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfExternalModelDefinitions(long level      =
        CompExtension.getDefaultLevel(), long version    =
        CompExtension.getDefaultVersion(), long pkgVersion =
        CompExtension.getDefaultPackageVersion())

        Creates a new ListOfExternalModelDefinitions with the given level,
        version, and package version.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfExternalModelDefinitions(CompPkgNamespaces compns)

        Creates a new ListOfExternalModelDefinitions with the given
        CompPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'compns' is the CompPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_ListOfExternalModelDefinitions(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def get(self, *args):
        """
        get(ListOfExternalModelDefinitions self, unsigned int n) -> ExternalModelDefinition
        get(ListOfExternalModelDefinitions self, unsigned int n) -> ExternalModelDefinition
        get(ListOfExternalModelDefinitions self, string sid) -> ExternalModelDefinition
        get(ListOfExternalModelDefinitions self, string sid) -> ExternalModelDefinition


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a ExternalModelDefinition from the ListOfExternalModelDefinitions.

        Parameter 'n' is the index number of the ExternalModelDefinition to
        get.

        Returns the nth ExternalModelDefinition in this
        ListOfExternalModelDefinitions. If the index 'n' is invalid, 'None' is
        returned.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a Model from the ListOfExternalModelDefinitions based on its
        identifier.

        Parameter 'sid' is a string representing the identifier  of the Model
        to get.

        Returns Model in this ListOfExternalModelDefinitions with the given
        'sid' or 'None' if no such Model exists.

        See also get(), size().

        """
        return _libsbml.ListOfExternalModelDefinitions_get(self, *args)


    def remove(self, *args):
        """
        remove(ListOfExternalModelDefinitions self, unsigned int n) -> ExternalModelDefinition
        remove(ListOfExternalModelDefinitions self, string sid) -> ExternalModelDefinition


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth item from this ListOfExternalModelDefinitions items
        and returns a pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the item to remove.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string &sid)

        Removes the item with given 'sid' from this ListOfModelDefinitions
        items and returns a pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'sid' is the id of the item to remove.

        See also size().

        """
        return _libsbml.ListOfExternalModelDefinitions_remove(self, *args)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfExternalModelDefinitions self) -> int


        Returns the libSBML type code for the objects contained in this ListOf
        (i.e., Model objects, if the list is non-empty).

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for objects contained in this list:
        SBML_COMP_EXTERNALMODELDEFINITION (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfExternalModelDefinitions_getItemTypeCode(self)


    def getElementName(self):
        """
        getElementName(ListOfExternalModelDefinitions self) -> string


        Returns the XML element name of this SBML object.

        Returns the name of this element, as a text string.

        """
        return _libsbml.ListOfExternalModelDefinitions_getElementName(self)

    __swig_destroy__ = _libsbml.delete_ListOfExternalModelDefinitions
    __del__ = lambda self: None
ListOfExternalModelDefinitions_swigregister = _libsbml.ListOfExternalModelDefinitions_swigregister
ListOfExternalModelDefinitions_swigregister(ListOfExternalModelDefinitions)

class ListOfModelDefinitions(ListOf):
    """

    [SBML 'comp' package]  A list of ModelDefinition objects.

    The ListOfModelDefinitions is a container for the extended
    SBMLDocument that allows one to define multiple Models in a single
    file for use in Submodel objects.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    See also ModelDefinition, ListOfDeletions,
    ListOfExternalModelDefinitions, ListOfPorts, ListOfReplacedElements,
    ListOfSubmodels.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfModelDefinitions, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfModelDefinitions, name)
    __repr__ = _swig_repr

    def clone(self):
        """
        clone(ListOfModelDefinitions self) -> ListOfModelDefinitions


        Creates and returns a deep copy of this ListOfModelDefinitions object.

        Returns a (deep) copy of this ListOfModelDefinitions.

        """
        return _libsbml.ListOfModelDefinitions_clone(self)


    def __init__(self, *args):
        """
        __init__(ListOfModelDefinitions self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ListOfModelDefinitions
        __init__(ListOfModelDefinitions self, unsigned int level, unsigned int version) -> ListOfModelDefinitions
        __init__(ListOfModelDefinitions self, unsigned int level) -> ListOfModelDefinitions
        __init__(ListOfModelDefinitions self) -> ListOfModelDefinitions
        __init__(ListOfModelDefinitions self, CompPkgNamespaces compns) -> ListOfModelDefinitions


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfModelDefinitions(long level      =
        CompExtension.getDefaultLevel(), long version    =
        CompExtension.getDefaultVersion(), long pkgVersion =
        CompExtension.getDefaultPackageVersion())

        Creates a new ListOfModelDefinitions with the given level, version,
        and package version.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfModelDefinitions(CompPkgNamespaces compns)

        Creates a new ListOfModelDefinitions with the given CompPkgNamespaces
        object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'compns' is the CompPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_ListOfModelDefinitions(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def get(self, *args):
        """
        get(ListOfModelDefinitions self, unsigned int n) -> ModelDefinition
        get(ListOfModelDefinitions self, unsigned int n) -> ModelDefinition
        get(ListOfModelDefinitions self, string sid) -> ModelDefinition
        get(ListOfModelDefinitions self, string sid) -> ModelDefinition


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a ModelDefinition from the ListOfModelDefinitions.

        Parameter 'n' is the index number of the ModelDefinition to get.

        Returns the nth ModelDefinition in this ListOfModelDefinitions. If the
        index 'n' is invalid, 'None' is returned.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a Model from the ListOfModelDefinitions based on its identifier.

        Parameter 'sid' is a string representing the identifier  of the Model
        to get.

        Returns Model in this ListOfModelDefinitions with the given 'sid' or
        'None' if no such Model exists.

        See also get(), size().

        """
        return _libsbml.ListOfModelDefinitions_get(self, *args)


    def remove(self, *args):
        """
        remove(ListOfModelDefinitions self, unsigned int n) -> ModelDefinition
        remove(ListOfModelDefinitions self, string sid) -> ModelDefinition


        Removes the nth item from this ListOfModelDefinitions items and
        returns a pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the item to remove.

        See also size().

        """
        return _libsbml.ListOfModelDefinitions_remove(self, *args)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfModelDefinitions self) -> int


        Returns the libSBML type code for the objects contained in this ListOf
        (i.e., ModelDefinition objects, if the list is non-empty).

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for objects contained in this list:
        SBML_COMP_MODELDEFINITION (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfModelDefinitions_getItemTypeCode(self)


    def getElementName(self):
        """
        getElementName(ListOfModelDefinitions self) -> string


        Returns the XML element name of this SBML object.

        Returns the name of this element, as a text string.

        """
        return _libsbml.ListOfModelDefinitions_getElementName(self)

    __swig_destroy__ = _libsbml.delete_ListOfModelDefinitions
    __del__ = lambda self: None
ListOfModelDefinitions_swigregister = _libsbml.ListOfModelDefinitions_swigregister
ListOfModelDefinitions_swigregister(ListOfModelDefinitions)

class ListOfPorts(ListOf):
    """

    [SBML 'comp' package]  A list of Port objects.

    The ListOfPorts is a container for the extended  Model for Port
    objects for that Model.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    See also Port, ListOfDeletions, ListOfExternalModelDefinitions,
    ListOfModelDefinitions, ListOfReplacedElements, ListOfSubmodels.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfPorts, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfPorts, name)
    __repr__ = _swig_repr

    def clone(self):
        """
        clone(ListOfPorts self) -> ListOfPorts


        Creates and returns a deep copy of this ListOfPorts object.

        Returns a (deep) copy of this ListOfPorts.

        """
        return _libsbml.ListOfPorts_clone(self)


    def __init__(self, *args):
        """
        __init__(ListOfPorts self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ListOfPorts
        __init__(ListOfPorts self, unsigned int level, unsigned int version) -> ListOfPorts
        __init__(ListOfPorts self, unsigned int level) -> ListOfPorts
        __init__(ListOfPorts self) -> ListOfPorts
        __init__(ListOfPorts self, CompPkgNamespaces compns) -> ListOfPorts


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfPorts(long level      =
        CompExtension.getDefaultLevel(), long version    =
        CompExtension.getDefaultVersion(), long pkgVersion =
        CompExtension.getDefaultPackageVersion())

        Creates a new ListOfPorts with the given level, version, and package
        version.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfPorts(CompPkgNamespaces compns)

        Creates a new ListOfPorts with the given CompPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'compns' is the CompPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_ListOfPorts(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def get(self, *args):
        """
        get(ListOfPorts self, unsigned int n) -> Port
        get(ListOfPorts self, unsigned int n) -> Port
        get(ListOfPorts self, string sid) -> Port
        get(ListOfPorts self, string sid) -> Port


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a Port from the ListOfPorts.

        Parameter 'n' is the index number of the Port to get.

        Returns the nth Port in this ListOfPorts. If the index 'n' is invalid,
        'None' is returned.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a Port from the ListOfPorts based on its identifier.

        Parameter 'sid' is a string representing the identifier  of the Port
        to get.

        Returns Port in this ListOfPorts with the given 'sid' or 'None' if no
        such Port exists.

        See also get(), size().

        """
        return _libsbml.ListOfPorts_get(self, *args)


    def remove(self, *args):
        """
        remove(ListOfPorts self, string sid) -> Port
        remove(ListOfPorts self, unsigned int n) -> Port


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth item from this ListOfPorts items and returns a pointer
        to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the item to remove.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes an item from this ListOfPorts items based on the identifier
        and returns a pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'sid' is string representing the id of the Port to remove.

        See also size().

        """
        return _libsbml.ListOfPorts_remove(self, *args)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfPorts self) -> int


        Returns the libSBML type code for the objects contained in this ListOf
        (i.e., Port objects, if the list is non-empty).

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for objects contained in this list:
        SBML_COMP_PORT (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfPorts_getItemTypeCode(self)


    def getElementName(self):
        """
        getElementName(ListOfPorts self) -> string


        Returns the XML element name of this SBML object.

        Returns the name of this element, as a text string.

        """
        return _libsbml.ListOfPorts_getElementName(self)


    def getElementBySId(self, id):
        """
        getElementBySId(ListOfPorts self, string id) -> SBase


        Returns the first child element found that has the given 'id' in the
        model-wide SId namespace, or 'None' if no such object is found.  Since
        the id of Port objects are in the PortSId namespace, no Port object is
        returned by this function.

        Parameter 'id' is string representing the id of the object to find.

        Returns a pointer to the SBase element with the given 'id'.

        """
        return _libsbml.ListOfPorts_getElementBySId(self, id)

    __swig_destroy__ = _libsbml.delete_ListOfPorts
    __del__ = lambda self: None
ListOfPorts_swigregister = _libsbml.ListOfPorts_swigregister
ListOfPorts_swigregister(ListOfPorts)

class ListOfReplacedElements(ListOf):
    """

    [SBML 'comp' package]  A list of ReplacedElement objects.

    The ListOfReplacedElements is a container for any SBase object.  It
    contains ReplacedElement objects, which point to elements the parent
    SBase object is to replace.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    See also ReplacedElement, ListOfDeletions,
    ListOfExternalModelDefinitions, ListOfModelDefinitions, ListOfPorts,
    ListOfSubmodels.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfReplacedElements, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfReplacedElements, name)
    __repr__ = _swig_repr

    def clone(self):
        """
        clone(ListOfReplacedElements self) -> ListOfReplacedElements


        Creates and returns a deep copy of this ListOfReplacedElements object.

        Returns a (deep) copy of this ListOfReplacedElements.

        """
        return _libsbml.ListOfReplacedElements_clone(self)


    def __init__(self, *args):
        """
        __init__(ListOfReplacedElements self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ListOfReplacedElements
        __init__(ListOfReplacedElements self, unsigned int level, unsigned int version) -> ListOfReplacedElements
        __init__(ListOfReplacedElements self, unsigned int level) -> ListOfReplacedElements
        __init__(ListOfReplacedElements self) -> ListOfReplacedElements
        __init__(ListOfReplacedElements self, CompPkgNamespaces compns) -> ListOfReplacedElements


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfReplacedElements(long level      =
        CompExtension.getDefaultLevel(), long version    =
        CompExtension.getDefaultVersion(), long pkgVersion =
        CompExtension.getDefaultPackageVersion())

        Creates a new ListOfReplacedElements with the given level, version,
        and package version.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfReplacedElements(CompPkgNamespaces compns)

        Creates a new ListOfReplacedElements with the given CompPkgNamespaces
        object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'compns' is the CompPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_ListOfReplacedElements(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def get(self, *args):
        """
        get(ListOfReplacedElements self, unsigned int n) -> ReplacedElement
        get(ListOfReplacedElements self, unsigned int n) -> ReplacedElement


        Get a ReplacedElement from the ListOfReplacedElements.

        Parameter 'n' is the index number of the ReplacedElement to get.

        Returns the nth ReplacedElement in this ListOfReplacedElements. If the
        index 'n' is invalid, 'None' is returned.

        See also size().

        """
        return _libsbml.ListOfReplacedElements_get(self, *args)


    def remove(self, n):
        """
        remove(ListOfReplacedElements self, unsigned int n) -> ReplacedElement


        Removes the nth item from this ListOfReplacedElements items and
        returns a pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the item to remove.

        See also size().

        """
        return _libsbml.ListOfReplacedElements_remove(self, n)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfReplacedElements self) -> int


        Returns the libSBML type code for the objects contained in this ListOf
        (i.e., ReplacedElements objects, if the list is non-empty).

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for objects contained in this list:
        SBML_COMP_REPLACEDELEMENT (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfReplacedElements_getItemTypeCode(self)


    def getElementName(self):
        """
        getElementName(ListOfReplacedElements self) -> string


        Returns the XML element name of this SBML object.

        Returns the name of this element, as a text string.

        """
        return _libsbml.ListOfReplacedElements_getElementName(self)

    __swig_destroy__ = _libsbml.delete_ListOfReplacedElements
    __del__ = lambda self: None
ListOfReplacedElements_swigregister = _libsbml.ListOfReplacedElements_swigregister
ListOfReplacedElements_swigregister(ListOfReplacedElements)

class ListOfSubmodels(ListOf):
    """

    [SBML 'comp' package]  A list of Submodel objects.

    The ListOfSubmodels is a container for the extended  Model that
    contains Submodel objects to be instantiated in that Model.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    See also Submodel, ListOfDeletions, ListOfExternalModelDefinitions,
    ListOfModelDefinitions, ListOfPorts, ListOfReplacedElements.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfSubmodels, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfSubmodels, name)
    __repr__ = _swig_repr

    def clone(self):
        """
        clone(ListOfSubmodels self) -> ListOfSubmodels


        Creates and returns a deep copy of this ListOfSubmodels object.

        Returns a (deep) copy of this ListOfSubmodels.

        """
        return _libsbml.ListOfSubmodels_clone(self)


    def __init__(self, *args):
        """
        __init__(ListOfSubmodels self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ListOfSubmodels
        __init__(ListOfSubmodels self, unsigned int level, unsigned int version) -> ListOfSubmodels
        __init__(ListOfSubmodels self, unsigned int level) -> ListOfSubmodels
        __init__(ListOfSubmodels self) -> ListOfSubmodels
        __init__(ListOfSubmodels self, CompPkgNamespaces compns) -> ListOfSubmodels


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfSubmodels(long level      =
        CompExtension.getDefaultLevel(), long version    =
        CompExtension.getDefaultVersion(), long pkgVersion =
        CompExtension.getDefaultPackageVersion())

        Creates a new ListOfSubmodels with the given level, version, and
        package version.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfSubmodels(CompPkgNamespaces compns)

        Creates a new ListOfSubmodels with the given CompPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'compns' is the CompPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_ListOfSubmodels(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def get(self, *args):
        """
        get(ListOfSubmodels self, unsigned int n) -> Submodel
        get(ListOfSubmodels self, unsigned int n) -> Submodel
        get(ListOfSubmodels self, string sid) -> Submodel
        get(ListOfSubmodels self, string sid) -> Submodel


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a Submodel from the ListOfSubmodels.

        Parameter 'n' is the index number of the Submodel to get.

        Returns the nth Submodel in this ListOfSubmodels. If the index 'n' is
        invalid, 'None' is returned.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a Model from the ListOfSubmodels based on its identifier.

        Parameter 'sid' is a string representing the identifier  of the Model
        to get.

        Returns Model in this ListOfSubmodels with the given 'sid' or 'None'
        if no such Model exists.

        See also get(), size().

        """
        return _libsbml.ListOfSubmodels_get(self, *args)


    def remove(self, *args):
        """
        remove(ListOfSubmodels self, unsigned int n) -> Submodel
        remove(ListOfSubmodels self, string sid) -> Submodel


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth item from this ListOfSubmodels items and returns a
        pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the item to remove.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes an item from this ListOfSubmodels items based on its
        identifier and returns a pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'sid' is string representing the identifier of the item to
        remove.

        See also size().

        """
        return _libsbml.ListOfSubmodels_remove(self, *args)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfSubmodels self) -> int


        Returns the libSBML type code for the objects contained in this ListOf
        (i.e., Submodel objects, if the list is non-empty).

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for objects contained in this list:
        SBML_COMP_SUBMODEL (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfSubmodels_getItemTypeCode(self)


    def getElementName(self):
        """
        getElementName(ListOfSubmodels self) -> string


        Returns the XML element name of this SBML object.

        Returns the name of this element, as a text string.

        """
        return _libsbml.ListOfSubmodels_getElementName(self)

    __swig_destroy__ = _libsbml.delete_ListOfSubmodels
    __del__ = lambda self: None
ListOfSubmodels_swigregister = _libsbml.ListOfSubmodels_swigregister
ListOfSubmodels_swigregister(ListOfSubmodels)

class ModelDefinition(Model):
    """

    [SBML 'comp' package]  A model used in model composition.

    The Hierarchical Model Composition ("comp") package allows multiple
    Model objects to be defined in a single SBMLDocument.  While these new
    Model objects are not new SBML classes, they are given a new name,
    <modelDefinition>, and reside in ListOfModelDefinition objects.  In
    libSBML, this class inherits from the Model class, changing only the
    expected parent of the object, and the XML name.

    An additional restriction is placed on the 'id' attribute of
    ModelDefinition objects:  not only must it be unique across all such
    attributes of type SId  within the ModelDefintion, it must also be
    unique across all Model,  ModelDefinition, and ExternalModelDefinition
    objects in the same SBMLDocument.

    """

    __swig_setmethods__ = {}
    for _s in [Model]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ModelDefinition, name, value)
    __swig_getmethods__ = {}
    for _s in [Model]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ModelDefinition, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ModelDefinition self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ModelDefinition
        __init__(ModelDefinition self, unsigned int level, unsigned int version) -> ModelDefinition
        __init__(ModelDefinition self, unsigned int level) -> ModelDefinition
        __init__(ModelDefinition self) -> ModelDefinition
        __init__(ModelDefinition self, CompPkgNamespaces compns) -> ModelDefinition
        __init__(ModelDefinition self, Model source) -> ModelDefinition


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ModelDefinition(Model source)

        Copy constructor from base Model object.

        Parameter 'source' is the instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            ModelDefinition(long level      =
        CompExtension.getDefaultLevel(), long version    =
        CompExtension.getDefaultVersion(), long pkgVersion =
        CompExtension.getDefaultPackageVersion())

        Creates a new ModelDefinition with the given level, version, and
        package version.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            ModelDefinition(CompPkgNamespaces compns)

        Creates a new ModelDefinition with the given CompPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'compns' is the CompPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_ModelDefinition(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ModelDefinition self) -> ModelDefinition


        Creates and returns a deep copy of this ModelDefinition object.

        Returns a (deep) copy of this ModelDefinition object.

        """
        return _libsbml.ModelDefinition_clone(self)

    __swig_destroy__ = _libsbml.delete_ModelDefinition
    __del__ = lambda self: None

    def getElementName(self):
        """
        getElementName(ModelDefinition self) -> string


        Returns the XML element name of this object.

        The only difference between a Model and a ModelDefinition is the
        element name ('modelDefinition').

        Returns the name of this element, as a text string.

        See also getTypeCode().

        """
        return _libsbml.ModelDefinition_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(ModelDefinition self) -> int


        Returns the libSBML type code of this object instance.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_COMP_MODELDEFINITION

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ModelDefinition_getTypeCode(self)


    def removeFromParentAndDelete(self):
        """
        removeFromParentAndDelete(ModelDefinition self) -> int


        Finds this Model's parent ListOfModelDefinitions and removes itself
        from it and deletes itself.

        This method actually just calls the SBase function, since the Model
        class overrides it, but that's actually what we want to happen here.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.ModelDefinition_removeFromParentAndDelete(self)

ModelDefinition_swigregister = _libsbml.ModelDefinition_swigregister
ModelDefinition_swigregister(ModelDefinition)

class Port(SBaseRef):
    """

    [SBML 'comp' package]  An interface to be used in composition.

    The Port class was introduced by the SBML Level 3 Hierarchical Model
    Composition ("comp") package to allow a Model to define a standard
    interface between it and other models that might use it as a submodel.
    It derives from the SBaseRef class, and the elements defined there
    refer to elements in the same parent Model as the Port object.  A Port
    object instance therefore uses those attributes to define a port for a
    component in a model.  When other SBaseRef or SBaseRef-derived classes
    refer to a Port object using a 'portRef' attribute, the element being
    referenced is the element the Port object itself points to.

    In the present formulation of the Hierarchical Model Composition
    package, the use of ports is not enforced, nor is there any mechanism
    to restrict which ports may be used in what ways---they are only an
    advisory construct.  Future versions of this SBML package may provide
    additional functionality to support explicit restrictions on port use.
    For the present definition of Hierarchical Model Composition, users of
    models containing ports are encouraged to respect the modeler's
    intention in defining ports, and use the port definitions to interact
    with components through their ports (when they have ports defined)
    rather than interact directly with the components.

    The required attribute 'id' is used to give an identifier to a Port
    object so that other objects can refer to it.  The attribute has type
    PortSId and is essentially identical to the SBML primitive type SId,
    except that its namespace is limited to the identifiers of Port
    objects defined within a Model object.  In parallel, the PortSId type
    has a companion type, PortSIdRef, that corresponds to the SBML
    primitive type SIdRef; the value space of PortSIdRef is limited to
    PortSId values.

    """

    __swig_setmethods__ = {}
    for _s in [SBaseRef]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Port, name, value)
    __swig_getmethods__ = {}
    for _s in [SBaseRef]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Port, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(Port self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> Port
        __init__(Port self, unsigned int level, unsigned int version) -> Port
        __init__(Port self, unsigned int level) -> Port
        __init__(Port self) -> Port
        __init__(Port self, CompPkgNamespaces compns) -> Port
        __init__(Port self, Port source) -> Port


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            Port(long level      = CompExtension.getDefaultLevel(), long
        version    = CompExtension.getDefaultVersion(), long pkgVersion =
        CompExtension.getDefaultPackageVersion())

        Creates a new Port with the given level, version, and package version.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            Port(Port source)

        Copy constructor.

        Parameter 'source' is the instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            Port(CompPkgNamespaces compns)

        Creates a new Port with the given CompPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'compns' is the CompPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_Port(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(Port self) -> Port


        Creates and returns a deep copy of this Port object.

        Returns a (deep) copy of this Port object.

        """
        return _libsbml.Port_clone(self)

    __swig_destroy__ = _libsbml.delete_Port
    __del__ = lambda self: None

    def getId(self):
        """
        getId(Port self) -> string


        Returns the value of the 'id' attribute of this Port.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is now recommended to use the
        getIdAttribute() function instead.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns the id of this Port.

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.Port_getId(self)


    def isSetId(self):
        """
        isSetId(Port self) -> bool


        Predicate returning 'True' or 'False' depending on whether this Port's
        'id' attribute has been set.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns 'True' if the 'id' attribute of this SBML object is set,
        'False' otherwise.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is recommended that callers use
        isSetIdAttribute() instead.

        See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(),
        isSetIdAttribute().

        """
        return _libsbml.Port_isSetId(self)


    def setId(self, sid):
        """
        setId(Port self, string sid) -> int


        Sets the value of the 'id' attribute of this Port.

        The string 'sid' is copied.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Parameter 'sid' is the string to use as the identifier of this object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.Port_setId(self, sid)


    def unsetId(self):
        """
        unsetId(Port self) -> int


        Unsets the value of the 'id' attribute of this Port.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.Port_unsetId(self)


    def getName(self):
        """
        getName(Port self) -> string


        Returns the value of the 'name' attribute of this Port object.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns the name of this SBML object, or the empty string if not set
        or unsettable.

        See also getIdAttribute(), isSetName(), setName(), unsetName().

        """
        return _libsbml.Port_getName(self)


    def isSetName(self):
        """
        isSetName(Port self) -> bool


        Predicate returning 'True' or 'False' depending on whether this Port's
        'name' attribute has been set.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns 'True' if the 'name' attribute of this SBML object is set,
        'False' otherwise.

        See also getName(), setName(), unsetName().

        """
        return _libsbml.Port_isSetName(self)


    def setName(self, name):
        """
        setName(Port self, string name) -> int


        Sets the value of the 'name' attribute of this Port.

        The string in 'name' is copied.

        Parameter 'name' is the new name for the SBML object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Port_setName(self, name)


    def unsetName(self):
        """
        unsetName(Port self) -> int


        Unsets the value of the 'name' attribute of this Port.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getName(), setName(), isSetName().

        """
        return _libsbml.Port_unsetName(self)


    def setPortRef(self, id):
        """
        setPortRef(Port self, string id) -> int


        Overrides SBaseRef::setPortRef to always fail, because Port objects
        themselves cannot refer to model elements by PortSId.

        Parameter 'id' is the identifier to set for the port reference.

        Returns integer value indicating failure of the function.   The
        possible value returned by this function is:

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Port_setPortRef(self, id)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(Port self) -> bool


        Returns 'True' if the 'id' attribute is set, and if exactly one of the
        optional attributes of SBaseRef (portRef, idRef, metaIdRef,  and
        unitRef)are set.

        Returns boolean: 'true' if the attributes are correctly set; 'false'
        if not.

        """
        return _libsbml.Port_hasRequiredAttributes(self)


    def getElementName(self):
        """
        getElementName(Port self) -> string


        Returns the XML element name of this SBML object.

        Returns the name of this element, as a text string.

        """
        return _libsbml.Port_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(Port self) -> int


        Returns the libSBML type code of this object instance.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_COMP_PORT.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.Port_getTypeCode(self)


    def saveReferencedElement(self):
        """
        saveReferencedElement(Port self) -> int


        Finds and stores the referenced object by finding its Model parent,
        calling 'getReferencedElementFrom()' on that model, and storing the
        result.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Port_saveReferencedElement(self)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(Port self, string oldid, string newid)


        Replaces all uses of a given 'SIdRef' type attribute value with
        another value.

        In SBML, object identifiers are of a data type called SId. In SBML
        Level 3, an explicit data type called SIdRef was introduced for
        attribute values that refer to SId values; in previous Levels of SBML,
        this data type did not exist and attributes were simply described to
        as 'referring to an identifier', but the effective data type was the
        same as SIdRef in Level 3.  These and other methods of libSBML refer
        to the type SIdRef for all Levels of SBML, even if the corresponding
        SBML specification did not explicitly name the data type.

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas in MathML content, comparing the referenced
        identifiers to the value of 'oldid'.  If any matches are found, the
        matching values are replaced with 'newid'.  The method does not
        descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.Port_renameSIdRefs(self, oldid, newid)


    def renameUnitSIdRefs(self, oldid, newid):
        """
        renameUnitSIdRefs(Port self, string oldid, string newid)


        Replaces all uses of a given 'UnitSIdRef' type attribute value with
        another value.

        In SBML, unit definitions have identifiers of type UnitSId.  In SBML
        Level 3, an explicit data type called UnitSIdRef was introduced for
        attribute values that refer to UnitSId values; in previous Levels of
        SBML, this data type did not exist and attributes were simply
        described to as 'referring to a unit identifier', but the effective
        data type was the same as UnitSIdRef in Level 3.  These and other
        methods of libSBML refer to the type UnitSIdRef for all Levels of
        SBML, even if the corresponding SBML specification did not explicitly
        name the data type.

        This method works by looking at all unit identifier attribute values
        (including, if appropriate, inside mathematical formulas), comparing
        the referenced unit identifiers to the value of 'oldid'.  If any
        matches are found, the matching values are replaced with 'newid'.  The
        method does not descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.Port_renameUnitSIdRefs(self, oldid, newid)


    def renameMetaIdRefs(self, oldid, newid):
        """
        renameMetaIdRefs(Port self, string oldid, string newid)


        Replaces all uses of a given meta identifier attribute value with
        another value.

        In SBML, object 'meta' identifiers are of the XML data type ID; the
        SBML object attribute itself is typically named metaid.  All
        attributes that hold values referring to values of type ID are of the
        XML data type IDREF.  They are also sometimes informally referred to
        as 'metaid refs', in analogy to the SBML-defined type SIdRef.

        This method works by looking at all meta-identifier attribute values,
        comparing the identifiers to the value of 'oldid'.  If any matches are
        found, the matching identifiers are replaced with 'newid'.  The method
        does not descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.Port_renameMetaIdRefs(self, oldid, newid)

Port_swigregister = _libsbml.Port_swigregister
Port_swigregister(Port)

class ReplacedBy(Replacing):
    """

    [SBML 'comp' package]  Indicates an object replaced by another.

    The ReplacedBy class was introduced by the SBML Level 3 Hierarchical
    Model Composition ("comp") package to allow submodel elements to be
    'canonical' versions of the element while still allowing the parent
    model to reference those elements.  Whereas a ReplacedElement object
    indicates that the containing object replaces another, a ReplacedBy
    object indicates the converse: the parent object is to be replaced by
    another object. As is the case with ReplacedElement, the ReplacedBy
    class inherits from SBaseRef.   It additionally defines one required
    attribute ('submodelRef'), defined in  libSBML in the Replacing class.

    """

    __swig_setmethods__ = {}
    for _s in [Replacing]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ReplacedBy, name, value)
    __swig_getmethods__ = {}
    for _s in [Replacing]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ReplacedBy, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ReplacedBy self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ReplacedBy
        __init__(ReplacedBy self, unsigned int level, unsigned int version) -> ReplacedBy
        __init__(ReplacedBy self, unsigned int level) -> ReplacedBy
        __init__(ReplacedBy self) -> ReplacedBy
        __init__(ReplacedBy self, CompPkgNamespaces compns) -> ReplacedBy
        __init__(ReplacedBy self, ReplacedBy source) -> ReplacedBy


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ReplacedBy(ReplacedBy source)

        Copy constructor.

        Parameter 'source' is the instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            ReplacedBy(long level      = CompExtension.getDefaultLevel(),
        long version    = CompExtension.getDefaultVersion(), long pkgVersion =
        CompExtension.getDefaultPackageVersion())

        Creates a new ReplacedBy with the given level, version, and package
        version.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            ReplacedBy(CompPkgNamespaces compns)

        Creates a new ReplacedBy with the given CompPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'compns' is the CompPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_ReplacedBy(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ReplacedBy self) -> ReplacedBy


        Creates and returns a deep copy of this ReplacedBy object.

        Returns a (deep) copy of this ReplacedBy object.

        """
        return _libsbml.ReplacedBy_clone(self)

    __swig_destroy__ = _libsbml.delete_ReplacedBy
    __del__ = lambda self: None

    def getElementName(self):
        """
        getElementName(ReplacedBy self) -> string


        Returns the XML element name of this SBML object.

        Returns the name of this element, as a text string.

        """
        return _libsbml.ReplacedBy_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(ReplacedBy self) -> int


        Returns the libSBML type code of this object instance.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_COMP_REPLACEDBY.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ReplacedBy_getTypeCode(self)


    def removeFromParentAndDelete(self):
        """
        removeFromParentAndDelete(ReplacedBy self) -> int


        Finds this ReplacedBy's SBase parent, gets the "comp" plugin from
        it, and tells that to remove this.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.ReplacedBy_removeFromParentAndDelete(self)


    def updateIDs(self, oldnames, newnames):
        """
        updateIDs(ReplacedBy self, SBase oldnames, SBase newnames) -> int


        Internal implementation method.

        """
        return _libsbml.ReplacedBy_updateIDs(self, oldnames, newnames)

ReplacedBy_swigregister = _libsbml.ReplacedBy_swigregister
ReplacedBy_swigregister(ReplacedBy)

class ReplacedElement(Replacing):
    """

    [SBML 'comp' package]  Indicates an object replaces another.

    The ReplacedElement class was introduced by the SBML Level 3
    Hierarchical Model Composition ("comp") package to allow submodel
    elements to be replaced, but still allow references to those elements
    to be valid.  A ReplacedElement object is essentially a pointer to a
    submodel object that should be considered 'replaced'.  The object
    holding the ReplacedElement instance is the one doing the replacing;
    the object pointed to by the ReplacedElement object is the object
    being replaced.

    A replacement implies that dependencies involving the replaced object
    must be updated: all references to the replaced object elsewhere in
    the model are taken to refer to the replacement object instead.  For
    example, if one species replaces another, then any reference to the
    original species in mathematical formulas, or lists of reactants or
    products or modifiers in reactions, or initial assignments, or any
    other SBML construct, are taken to refer to the replacement species,
    with its value possibly modified by either this object's
    'conversionFactor' attribute or the relevant submodel's conversion
    factors. Moreover, any  annotations that refer to the replaced
    species' 'metaid' value must be made to refer to the replacement
    species' 'metaid' value instead; and anything else that referred
    either to an object identifier (i.e., attributes such as the 'id'
    attribute whose types inherit from the SId primitive data type) or the
    meta identifier (i.e., the 'metaid' attribute or any other attribute
    that inherits from the ID primitive data type) must be made to refer
    to the replacement species object instead.

    It is worth noting that local parameters (inside Reaction objects)
    pose an interesting edge case for these rules. In order to determine
    which element is pointed to by a <cn> element within the <math>
    element of a KineticLaw object, it is necessary to examine the local
    parameters of that kinetic law's parent Reaction object.  Whether the
    <cn> element is considered to point to something new, then, depends on
    whether it pointed to the local parameter and whether that local
    parameter was replaced, even if the text of the element matched the
    SId value of another element in the model. Note that local parameters
    may only effectively be replaced by global parameters, since
    references to its SId are only valid from within the Reaction element
    to which it belongs.

    When referencing an element within the Submodel pointed to by the
    'submodelRef' attribute (defined in libSBML in the Replacing class),
    any of the four attributes inherited from  SBaseRef for the purpose
    may be used (portRef, idRef, unitRef, or  metaIdRef), or a new
    optional attribute 'deletion' may be used.  This attribute must be the
    identifier of a Deletion object in the parent Model of the
    ReplacedElement (i.e., the value of some Deletion object's 'id'
    attribute).  When 'deletion' is set, it means the ReplacedElement
    object is actually an annotation to indicate that the replacement
    object replaces something deleted from a submodel.  The use of the
    'deletion' attribute overrides the use of the attributes inherited
    from SBaseRef: instead of using, e.g., 'portRef' or 'idRef', the
    ReplacedElement instance sets 'deletion' to the identifier of the
    Deletion object.  In addition, the referenced Deletion must be a child
    of the Submodel referenced by the 'submodelRef' attribute.

    The use of ReplacedElement objects to refer to deletions has no effect
    on the composition of models or the mathematical properties of the
    result.  It serves instead to help record the decision-making process
    that lead to a given model.  It can be particularly useful for
    visualization purposes, as well as to serve as scaffolding where other
    types of annotations can be added using the normal Annotation
    subcomponents available on all SBase objects in SBML.

    As with the Submodel class, it may be that the units of the replaced
    element may not match the units of the replacement element.  In this
    case,  the optional 'conversionFactor' attribute may be used.  This
    attribute, if present, defines how to transform or rescale the
    replaced object's value so that it is appropriate for the new contexts
    in which the object appears.  This attribute takes a value of type
    SIdRef, and the value must refer to a Parameter object instance
    defined in the model.  This parameter then acts as a conversion
    factor.

    The value of the conversion factor should be defined such that a
    single unit of the replaced element multiplied by the conversion
    factor should equal a single unit of the replacement element, and the
    units of the conversion factor should be commensurate with that
    transformation.  The referenced Parameter may be non-constant,
    particularly if a Species is replaced by a Species with a different
    'hasOnlySubstanceUnits' attribute value, thus changing amount to
    concentration, or visa versa.

    """

    __swig_setmethods__ = {}
    for _s in [Replacing]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ReplacedElement, name, value)
    __swig_getmethods__ = {}
    for _s in [Replacing]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ReplacedElement, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ReplacedElement self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ReplacedElement
        __init__(ReplacedElement self, unsigned int level, unsigned int version) -> ReplacedElement
        __init__(ReplacedElement self, unsigned int level) -> ReplacedElement
        __init__(ReplacedElement self) -> ReplacedElement
        __init__(ReplacedElement self, CompPkgNamespaces compns) -> ReplacedElement
        __init__(ReplacedElement self, ReplacedElement source) -> ReplacedElement


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ReplacedElement(long level      =
        CompExtension.getDefaultLevel(), long version    =
        CompExtension.getDefaultVersion(), long pkgVersion =
        CompExtension.getDefaultPackageVersion())

        Creates a new ReplacedElement with the given level, version, and
        package version.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            ReplacedElement(CompPkgNamespaces compns)

        Creates a new ReplacedElement with the given CompPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'compns' is the CompPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        ______________________________________________________________________
        Method variant with the following signature:

            ReplacedElement(ReplacedElement source)

        Copy constructor.

        Parameter 'source' is the instance to copy.

        """
        this = _libsbml.new_ReplacedElement(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ReplacedElement self) -> ReplacedElement


        Creates and returns a deep copy of this ReplacedElement object.

        Returns a (deep) copy of this ReplacedElement object.

        """
        return _libsbml.ReplacedElement_clone(self)

    __swig_destroy__ = _libsbml.delete_ReplacedElement
    __del__ = lambda self: None

    def getConversionFactor(self):
        """
        getConversionFactor(ReplacedElement self) -> string


        Returns the value of the 'conversionFactor' attribute of this
        ReplacedElement.

        Returns the value of the 'conversionFactor' attribute of this
        ReplacedElement.

        """
        return _libsbml.ReplacedElement_getConversionFactor(self)


    def isSetConversionFactor(self):
        """
        isSetConversionFactor(ReplacedElement self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        ReplacedElement's 'conversionFactor' attribute has been set.

        Returns 'True' if this ReplacedElement's 'conversionFactor' attribute
        has been set,  otherwise 'False' is returned.

        """
        return _libsbml.ReplacedElement_isSetConversionFactor(self)


    def setConversionFactor(self, id):
        """
        setConversionFactor(ReplacedElement self, string id) -> int


        Sets the value of the 'conversionFactor' attribute of this
        ReplacedElement.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.ReplacedElement_setConversionFactor(self, id)


    def unsetConversionFactor(self):
        """
        unsetConversionFactor(ReplacedElement self) -> int


        Unsets the value of the 'conversionFactor' attribute of this
        ReplacedElement.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.ReplacedElement_unsetConversionFactor(self)


    def getDeletion(self):
        """
        getDeletion(ReplacedElement self) -> string


        Returns the value of the 'deletion' attribute of this ReplacedElement.

        Returns the value of the 'deletion' attribute of this ReplacedElement.

        """
        return _libsbml.ReplacedElement_getDeletion(self)


    def isSetDeletion(self):
        """
        isSetDeletion(ReplacedElement self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        SBaseRef's 'deletion' attribute has been set.

        Returns 'True' if this ReplacedElement's 'deletion' attribute has been
        set,  otherwise 'False' is returned.

        """
        return _libsbml.ReplacedElement_isSetDeletion(self)


    def setDeletion(self, id):
        """
        setDeletion(ReplacedElement self, string id) -> int


        Sets the value of the 'deletion' attribute of this ReplacedElement.

        This method fails if the id is not a valid syntax for an SIdRef
        (LIBSBML_INVALID_ATTRIBUTE_VALUE), or if the SBaseRef already points
        to an element of the submodel using a different interface
        (LIBSBML_OPERATION_FAILED).  A ReplacedElement must use exactly one
        method to point to a submodel element: deletion, port, idRef, unitRef,
        or metaIdRef.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.ReplacedElement_setDeletion(self, id)


    def unsetDeletion(self):
        """
        unsetDeletion(ReplacedElement self) -> int


        Unsets the value of the 'deletion' attribute of this ReplacedElement.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.ReplacedElement_unsetDeletion(self)


    def getElementName(self):
        """
        getElementName(ReplacedElement self) -> string


        Returns the XML element name of this SBML object.

        Returns the name of this element, as a text string.

        """
        return _libsbml.ReplacedElement_getElementName(self)


    def getNumReferents(self):
        """
        getNumReferents(ReplacedElement self) -> int


        Returns how many elements are being referred to by this
        ReplacedElement.  A valid ReplacedElement will have exactly one.
        Possible referents are deletion, port, idRef, unitRef, and metaIdRef.

        Returns integer value between 0 and 5: the number of different ways
        this element points to its referent.

        """
        return _libsbml.ReplacedElement_getNumReferents(self)


    def getTypeCode(self):
        """
        getTypeCode(ReplacedElement self) -> int


        Returns the libSBML type code of this object instance.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_COMP_REPLACEDELEMENT.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ReplacedElement_getTypeCode(self)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(ReplacedElement self, string oldid, string newid)


        Replaces all uses of a given 'SIdRef' type attribute value with
        another value.

        In SBML, object identifiers are of a data type called SId. In SBML
        Level 3, an explicit data type called SIdRef was introduced for
        attribute values that refer to SId values; in previous Levels of SBML,
        this data type did not exist and attributes were simply described to
        as 'referring to an identifier', but the effective data type was the
        same as SIdRef in Level 3.  These and other methods of libSBML refer
        to the type SIdRef for all Levels of SBML, even if the corresponding
        SBML specification did not explicitly name the data type.

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas in MathML content, comparing the referenced
        identifiers to the value of 'oldid'.  If any matches are found, the
        matching values are replaced with 'newid'.  The method does not
        descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.ReplacedElement_renameSIdRefs(self, oldid, newid)


    def getReferencedElementFrom(self, model):
        """
        getReferencedElementFrom(ReplacedElement self, Model model) -> SBase


        Finds the SBase object this ReplacedElement object points to, if any.

        """
        return _libsbml.ReplacedElement_getReferencedElementFrom(self, model)

ReplacedElement_swigregister = _libsbml.ReplacedElement_swigregister
ReplacedElement_swigregister(ReplacedElement)

class Submodel(CompBase):
    """

    [SBML 'comp' package]  A model instance inside another model.

    The Submodel class was introduced by the SBML Level 3 Hierarchical
    Model Composition ("comp") package as the principle way by which
    models are structured hierarchically.  Submodels are instantiations of
    models contained within other models.  They reference another Model
    that is to be instantiated within its parent Model, and additionally
    define how that Model is to be modified before instantiation.

    The Submodel object class has a required attribute 'modelRef', which
    must reference another Model or ExternalModelDefinition object present
    in the SBML Document.  This referenced Model is the model to be
    instantiated.

    It also has a required attribute, 'id', to give the submodel a unique
    identifier by which other parts of an SBML model definition can refer
    to it, and an optional 'name' attribute of type 'string.'  Identifiers
    and names must be used according to the guidelines described in the
    SBML specification.

    The Submodel class also provides constructs that define how the
    referenced Model object is to be modified before it is instantiated in
    the enclosing model.  If numerical values in the referenced model must
    be changed in order  to fit them into their new context as part of the
    submodel, the changes can  be handled through conversion factors.  If
    one or more structural features  in the referenced model are
    undesirable and should be removed, the changes  can be handled through
    deletions.  (For example, an initial assignment or  reaction may not
    be relevant in its new context and should be removed.)

    In some cases, the referenced Model may have been written with
    different units than the containing model.  For most model elements,
    this is not a problem: it is already possible to have Species and
    Parameter objects with different units in a single model, for example,
    so in this case the resulting hierarchical model would be treated in
    exactly the same way as any other model with Species and Parameters
    with different units.

    However, two units in SBML models are fixed and must not vary between
    SBML elements: time and extent.  The units of time are set once per
    model, and affect the core elements of RateRule, KineticLaw, Delay,
    and the csymbols 'time' and 'delay'.  Even if the model does not
    explicitly state what the units of time actually are, they are defined
    to be consistent across the model, and therefore might differ from the
    units of time across a parent model.  To correct this imbalance, the
    optional attribute 'timeConversionFactor' may be used, which, if
    defined, must reference a constant parameter in the parent model. The
    value of the time conversion factor should be defined such that a
    single unit of time in the Submodel multiplied by the time conversion
    factor should equal a single unit of time in the parent model.

    Extent is the unit in SBML that defines how the KineticLaw of a
    Reaction affects species quantities: kinetic laws are defined to be in
    units of extent/time.  No other SBML core construct is defined in
    terms of extent. If the effective units of extent in a submodel differ
    from the effective units of extent in the parent model (regardless of
    whether either defined what those units actually are), the optional
    attribute 'extentConversionFactor' may be used, which, if defined,
    must reference a constant parameter in the parent model. The value of
    the extent conversion factor should be defined such that a single unit
    of extent in the Submodel multiplied by the extent conversion factor
    should equal a single unit of extent in the parent model.

    If features of the referenced model must be removed, a Deletion should
    be added  to the Submodel object.  A Submodel may contain a child
    ListOfDeletions, which in turn may contain one or more Deletion items.
    Each Deletion references a single element of the referenced Model that
    must be removed before instantiating that Model as a submodel of the
    parent Model.

    """

    __swig_setmethods__ = {}
    for _s in [CompBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Submodel, name, value)
    __swig_getmethods__ = {}
    for _s in [CompBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Submodel, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(Submodel self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> Submodel
        __init__(Submodel self, unsigned int level, unsigned int version) -> Submodel
        __init__(Submodel self, unsigned int level) -> Submodel
        __init__(Submodel self) -> Submodel
        __init__(Submodel self, CompPkgNamespaces compns) -> Submodel
        __init__(Submodel self, Submodel source) -> Submodel


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            Submodel(long level      = CompExtension.getDefaultLevel(),
        long version    = CompExtension.getDefaultVersion(), long pkgVersion =
        CompExtension.getDefaultPackageVersion())

        Creates a new Submodel with the given level, version, and package
        version.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            Submodel(Submodel source)

        Copy constructor.

        Parameter 'source' is the instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            Submodel(CompPkgNamespaces compns)

        Creates a new Submodel with the given CompPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'compns' is the CompPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_Submodel(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(Submodel self) -> Submodel


        Creates and returns a deep copy of this Submodel object.

        Returns a (deep) copy of this Submodel object.

        """
        return _libsbml.Submodel_clone(self)

    __swig_destroy__ = _libsbml.delete_Submodel
    __del__ = lambda self: None

    def getElementBySId(self, id):
        """
        getElementBySId(Submodel self, string id) -> SBase


        Returns the first child element found that has the given 'id' in the
        model-wide SId namespace, or 'None' if no such object is found.

        Parameter 'id' is string representing the id of the object to find.

        Returns a pointer to the SBase element with the given 'id'.

        """
        return _libsbml.Submodel_getElementBySId(self, id)


    def getElementByMetaId(self, metaid):
        """
        getElementByMetaId(Submodel self, string metaid) -> SBase


        Returns the first child element it can find with the given 'metaid',
        or itself if it has the given 'metaid', or 'None' if no such object is
        found.

        Parameter 'metaid' is string representing the metaid of the object to
        find.

        Returns a pointer to the SBase element with the given 'metaid'.

        """
        return _libsbml.Submodel_getElementByMetaId(self, metaid)


    def getId(self):
        """
        getId(Submodel self) -> string


        Returns the value of the 'id' attribute of this Submodel.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is now recommended to use the
        getIdAttribute() function instead.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns the id of this Submodel.

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.Submodel_getId(self)


    def isSetId(self):
        """
        isSetId(Submodel self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        Submodel's 'id' attribute has been set.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns 'True' if the 'id' attribute of this SBML object is set,
        'False' otherwise.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is recommended that callers use
        isSetIdAttribute() instead.

        See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(),
        isSetIdAttribute().

        """
        return _libsbml.Submodel_isSetId(self)


    def setId(self, sid):
        """
        setId(Submodel self, string sid) -> int


        Sets the value of the 'id' attribute of this Submodel.

        The string 'sid' is copied.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Parameter 'sid' is the string to use as the identifier of this object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.Submodel_setId(self, sid)


    def unsetId(self):
        """
        unsetId(Submodel self) -> int


        Unsets the value of the 'id' attribute of this Submodel.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.Submodel_unsetId(self)


    def getName(self):
        """
        getName(Submodel self) -> string


        Returns the value of the 'name' attribute of this Submodel object.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns the name of this SBML object, or the empty string if not set
        or unsettable.

        See also getIdAttribute(), isSetName(), setName(), unsetName().

        """
        return _libsbml.Submodel_getName(self)


    def isSetName(self):
        """
        isSetName(Submodel self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        Submodel's 'name' attribute has been set.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns 'True' if the 'name' attribute of this SBML object is set,
        'False' otherwise.

        See also getName(), setName(), unsetName().

        """
        return _libsbml.Submodel_isSetName(self)


    def setName(self, name):
        """
        setName(Submodel self, string name) -> int


        Sets the value of the 'name' attribute of this Submodel.

        The string in 'name' is copied.

        Parameter 'name' is the new name for the SBML object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Submodel_setName(self, name)


    def unsetName(self):
        """
        unsetName(Submodel self) -> int


        Unsets the value of the 'name' attribute of this Submodel.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getName(), setName(), isSetName().

        """
        return _libsbml.Submodel_unsetName(self)


    def getModelRef(self):
        """
        getModelRef(Submodel self) -> string


        Returns the value of the 'modelRef' attribute of this Submodel.

        Returns the value of the 'modelRef' attribute of this Submodel.

        """
        return _libsbml.Submodel_getModelRef(self)


    def isSetModelRef(self):
        """
        isSetModelRef(Submodel self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        Submodel's 'modelRef' attribute has been set.

        Returns 'True' if this Submodel's 'modelRef' attribute has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.Submodel_isSetModelRef(self)


    def setModelRef(self, modelRef):
        """
        setModelRef(Submodel self, string modelRef) -> int


        Sets the value of the 'modelRef' attribute of this Submodel.  Fails if
        the modelRef is not a valid syntax for an SIdRef.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Submodel_setModelRef(self, modelRef)


    def unsetModelRef(self):
        """
        unsetModelRef(Submodel self) -> int


        Unsets the value of the 'modelRef' attribute of this Submodel.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Submodel_unsetModelRef(self)


    def getSubstanceConversionFactor(self):
        """
        getSubstanceConversionFactor(Submodel self) -> string


        Returns an empty string, since 'substanceConversionFactor' is not a
        part of the comp spec.

        Returns an empty string.

        """
        return _libsbml.Submodel_getSubstanceConversionFactor(self)


    def isSetSubstanceConversionFactor(self):
        """
        isSetSubstanceConversionFactor(Submodel self) -> bool


        Returns 'False,' since 'substanceConversionFactor' is not a part of
        the comp spec.

        Returns 'False.'

        """
        return _libsbml.Submodel_isSetSubstanceConversionFactor(self)


    def setSubstanceConversionFactor(self, id):
        """
        setSubstanceConversionFactor(Submodel self, string id) -> int


        Automatically fails, since 'substanceConversionFactor' is not a part
        of the comp spec.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Submodel_setSubstanceConversionFactor(self, id)


    def unsetSubstanceConversionFactor(self):
        """
        unsetSubstanceConversionFactor(Submodel self) -> int


        Automatically fails, since 'substanceConversionFactor' is not a part
        of the comp spec.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Submodel_unsetSubstanceConversionFactor(self)


    def getTimeConversionFactor(self):
        """
        getTimeConversionFactor(Submodel self) -> string


        Returns the value of the 'timeConversionFactor' attribute of this
        Submodel.

        Returns the value of the 'timeConversionFactor' attribute of this
        Submodel.

        """
        return _libsbml.Submodel_getTimeConversionFactor(self)


    def isSetTimeConversionFactor(self):
        """
        isSetTimeConversionFactor(Submodel self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        Submodel's 'timeConversionFactor' attribute has been set.

        Returns 'True' if this Submodel's 'timeConversionFactor' attribute has
        been set,  otherwise 'False' is returned.

        """
        return _libsbml.Submodel_isSetTimeConversionFactor(self)


    def setTimeConversionFactor(self, id):
        """
        setTimeConversionFactor(Submodel self, string id) -> int


        Sets the value of the 'timeConversionFactor' attribute of this
        Submodel. Fails if the id is not a valid syntax for an SIdRef.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Submodel_setTimeConversionFactor(self, id)


    def unsetTimeConversionFactor(self):
        """
        unsetTimeConversionFactor(Submodel self) -> int


        Unsets the value of the 'timeConversionFactor' attribute of this
        Submodel.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Submodel_unsetTimeConversionFactor(self)


    def getExtentConversionFactor(self):
        """
        getExtentConversionFactor(Submodel self) -> string


        Returns the value of the 'extentConversionFactor' attribute of this
        Submodel.

        Returns the value of the 'extentConversionFactor' attribute of this
        Submodel.

        """
        return _libsbml.Submodel_getExtentConversionFactor(self)


    def isSetExtentConversionFactor(self):
        """
        isSetExtentConversionFactor(Submodel self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        Submodel's 'extentConversionFactor' attribute has been set.

        Returns 'True' if this Submodel's 'extentConversionFactor' attribute
        has been set,  otherwise 'False' is returned.

        """
        return _libsbml.Submodel_isSetExtentConversionFactor(self)


    def setExtentConversionFactor(self, id):
        """
        setExtentConversionFactor(Submodel self, string id) -> int


        Sets the value of the 'extentConversionFactor' attribute of this
        Submodel.  Fails if the id is not a valid syntax for an SIdRef.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Submodel_setExtentConversionFactor(self, id)


    def unsetExtentConversionFactor(self):
        """
        unsetExtentConversionFactor(Submodel self) -> int


        Unsets the value of the 'extentConversionFactor' attribute of this
        Submodel.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Submodel_unsetExtentConversionFactor(self)


    def getListOfDeletions(self, *args):
        """
        getListOfDeletions(Submodel self) -> ListOfDeletions
        getListOfDeletions(Submodel self) -> ListOfDeletions


        Returns the ListOf object that holds all deletions.

        Returns the ListOf object that holds all deletions.

        """
        return _libsbml.Submodel_getListOfDeletions(self, *args)


    def getDeletion(self, *args):
        """
        getDeletion(Submodel self, unsigned int n) -> Deletion
        getDeletion(Submodel self, unsigned int n) -> Deletion
        getDeletion(Submodel self, string id) -> Deletion
        getDeletion(Submodel self, string id) -> Deletion


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getDeletion(string id)

        Returns the deletion with the given 'id'. If the id is invalid, 'None'
        is returned.

        Parameter 'id' is the id of the Deletion to get.

        Returns the Deletion in the ListOfDeletions with the given 'id'.

        ______________________________________________________________________
        Method variant with the following signature:

            getDeletion(long n)

        Returns the deletion with the given 'index'. If the index is invalid,
        'None' is returned.

        Parameter 'n' is the index number of the Deletion to get.

        Returns the nth Deletion in the ListOfDeletions. If the index 'n' is
        invalid, 'None' is returned.

        """
        return _libsbml.Submodel_getDeletion(self, *args)


    def addDeletion(self, deletion):
        """
        addDeletion(Submodel self, Deletion deletion) -> int


        Adds a copy of the given Deletion object to the list of deletions.

        Parameter 'deletion' is the Deletion object to be added to the list of
        deletions.  Fails if the added deletion is 'None,' does not match the
        level/version/package of the parent object, or cannot be added to the
        list of deletions.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_PKG_VERSION_MISMATCH

        """
        return _libsbml.Submodel_addDeletion(self, deletion)


    def getNumDeletions(self):
        """
        getNumDeletions(Submodel self) -> unsigned int


        Returns the number of deletions for this Submodel.

        Returns the number of deletions for this Submodel.

        """
        return _libsbml.Submodel_getNumDeletions(self)


    def createDeletion(self):
        """
        createDeletion(Submodel self) -> Deletion


        Creates a Deletion object, adds it to the end of the deletion objects
        list and returns a pointer to the newly created object.

        Returns a newly created Deletion object.

        """
        return _libsbml.Submodel_createDeletion(self)


    def removeDeletion(self, *args):
        """
        removeDeletion(Submodel self, unsigned int index) -> Deletion
        removeDeletion(Submodel self, string sid) -> Deletion


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeDeletion(long index)

        Removes the deletion with the given 'index' from the Submodel. A
        pointer to the deletion that was removed is returned. If no deletion
        has been removed, 'None' is returned.

        Parameter 'index' is the index of the Deletion object to remove.

        Returns the Deletion object removed.  As mentioned above,  the caller
        owns the returned object. 'None' is returned if  the given 'index' is
        out of range.

        ______________________________________________________________________
        Method variant with the following signature:

            removeDeletion(string sid)

        Removes the deletion with the given identifier from the Submodel. A
        pointer to the deletion that was removed is returned. If no deletion
        has been removed, 'None' is returned.

        Parameter 'sid' is string representing the identifier of the Deletion
        object to remove.

        Returns the Deletion object removed.  As mentioned above,  the caller
        owns the returned object. 'None' is returned if  the given 'sid' is
        not found.

        """
        return _libsbml.Submodel_removeDeletion(self, *args)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(Submodel self) -> bool


        Returns 'True' if the 'submodel' attribute is set, and if
        getNumReferents() is exactly 1.

        Returns boolean: 'true' if the attributes are correctly set; 'false'
        if not.

        """
        return _libsbml.Submodel_hasRequiredAttributes(self)


    def getElementName(self):
        """
        getElementName(Submodel self) -> string


        Returns the XML element name of this SBML object.

        Returns the name of this element, as a text string.

        """
        return _libsbml.Submodel_getElementName(self)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(Submodel self, string oldid, string newid)


        Renames the conversion factor attributes on this element if 'oldid'
        matches.

        """
        return _libsbml.Submodel_renameSIdRefs(self, oldid, newid)


    def getTypeCode(self):
        """
        getTypeCode(Submodel self) -> int


        Returns the libSBML type code of this object instance.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_COMP_SUBMODEL.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.Submodel_getTypeCode(self)


    def connectToChild(self):
        """connectToChild(Submodel self)"""
        return _libsbml.Submodel_connectToChild(self)


    def createObject(self, stream):
        """
        createObject(Submodel self, XMLInputStream stream) -> SBase


        Internal implementation method.

        """
        return _libsbml.Submodel_createObject(self, stream)


    def instantiate(self):
        """
        instantiate(Submodel self) -> int


        Find and create a local copy of the Model object referenced by this
        Submodel.  Is recursive, in that if the instantiated Model contains
        any Submodel objects, those Submodels will themselves be instantiated.
        If an instantiated model previously existed, it is deleted and a new
        one is created.  For this reason, call this function only once, or
        call Submodel.getInstantiation().

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_OBJECT (which indicates this Submodel itself is
        invalid, and no Model can be instantiated from it)

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Submodel_instantiate(self)


    def performDeletions(self):
        """
        performDeletions(Submodel self) -> int


        Delete elements in the instantiated submodel, based on any Deletions
        from this Submodel's listOfDeletions.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_OBJECT (which indicates this Submodel itself is
        invalid, and no Model can be instantiated from it)

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Submodel_performDeletions(self)


    def replaceElement(self, toReplace, replacement):
        """
        replaceElement(Submodel self, SBase toReplace, SBase replacement) -> int


        Delete the element in question from the stored instantiated Model, and
        replace all references to it with references to the replacement
        object. LIBSBML_INVALID_OBJECT means that this Submodel itself or one
        of the passed-in objects are invalid. LIBSBML_OPERATION_FAILED means
        that the routine failed for some othe reason.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Submodel_replaceElement(self, toReplace, replacement)


    def getInstantiation(self, *args):
        """
        getInstantiation(Submodel self) -> Model
        getInstantiation(Submodel self) -> Model


        Get the instantiated Model this Submodel contains rules to create.
        Calls instantiate() automatically if this operation has not yet been
        performed, and/or if the operation failed the last time it was called.
        Any modifictions that have been performed with performDeletions(),
        replaceElement(), or convertTimeAndExtent() function calls will be
        included.

        Returns the instantiated Model object: a clone of the original,
        modified according to the performDeletions() and replaceElement()
        functions that have been called.  Returns None if any error is
        encountered.

        """
        return _libsbml.Submodel_getInstantiation(self, *args)


    def clearInstantiation(self):
        """
        clearInstantiation(Submodel self)


        Delete the instantiated Model, if it exists.

        """
        return _libsbml.Submodel_clearInstantiation(self)


    def convertTimeAndExtent(self):
        """
        convertTimeAndExtent(Submodel self) -> int


        Convert all references to time and extent in the instantiated Model,
        according to the timeConversionFactor and extentConversionFactor
        attributes.

        """
        return _libsbml.Submodel_convertTimeAndExtent(self)


    def clearProcessingCallbacks():
        """
        clearProcessingCallbacks()


        Internal implementation method.

        """
        return _libsbml.Submodel_clearProcessingCallbacks()

    clearProcessingCallbacks = staticmethod(clearProcessingCallbacks)

    def addProcessingCallback(cb, userdata=None):
        """
        addProcessingCallback(ModelProcessingCallback cb, void * userdata=None)
        addProcessingCallback(ModelProcessingCallback cb)


        Internal implementation method.

        """
        return _libsbml.Submodel_addProcessingCallback(cb, userdata)

    addProcessingCallback = staticmethod(addProcessingCallback)

    def getNumProcessingCallbacks():
        """
        getNumProcessingCallbacks() -> int


        Internal implementation method.

        """
        return _libsbml.Submodel_getNumProcessingCallbacks()

    getNumProcessingCallbacks = staticmethod(getNumProcessingCallbacks)

    def removeProcessingCallback(*args):
        """
        removeProcessingCallback(int index)
        removeProcessingCallback(ModelProcessingCallback cb)
        """
        return _libsbml.Submodel_removeProcessingCallback(*args)

    removeProcessingCallback = staticmethod(removeProcessingCallback)

    def getListOfAllInstantiatedElements(self):
        """getListOfAllInstantiatedElements(Submodel self) -> SBaseList"""
        return _libsbml.Submodel_getListOfAllInstantiatedElements(self)

Submodel_swigregister = _libsbml.Submodel_swigregister
Submodel_swigregister(Submodel)

def Submodel_clearProcessingCallbacks():
    """
    Submodel_clearProcessingCallbacks()


    Internal implementation method.

    """
    return _libsbml.Submodel_clearProcessingCallbacks()

def Submodel_addProcessingCallback(cb, userdata=None):
    """
    addProcessingCallback(ModelProcessingCallback cb, void * userdata=None)
    Submodel_addProcessingCallback(ModelProcessingCallback cb)


    Internal implementation method.

    """
    return _libsbml.Submodel_addProcessingCallback(cb, userdata)

def Submodel_getNumProcessingCallbacks():
    """
    Submodel_getNumProcessingCallbacks() -> int


    Internal implementation method.

    """
    return _libsbml.Submodel_getNumProcessingCallbacks()

def Submodel_removeProcessingCallback(*args):
    """
    removeProcessingCallback(int index)
    Submodel_removeProcessingCallback(ModelProcessingCallback cb)
    """
    return _libsbml.Submodel_removeProcessingCallback(*args)

CompUnknown = _libsbml.CompUnknown
CompNSUndeclared = _libsbml.CompNSUndeclared
CompElementNotInNs = _libsbml.CompElementNotInNs
CompDuplicateComponentId = _libsbml.CompDuplicateComponentId
CompUniqueModelIds = _libsbml.CompUniqueModelIds
CompUniquePortIds = _libsbml.CompUniquePortIds
CompInvalidSIdSyntax = _libsbml.CompInvalidSIdSyntax
CompInvalidSubmodelRefSyntax = _libsbml.CompInvalidSubmodelRefSyntax
CompInvalidDeletionSyntax = _libsbml.CompInvalidDeletionSyntax
CompInvalidConversionFactorSyntax = _libsbml.CompInvalidConversionFactorSyntax
CompInvalidNameSyntax = _libsbml.CompInvalidNameSyntax
CompReplacedUnitsShouldMatch = _libsbml.CompReplacedUnitsShouldMatch
CompOneListOfReplacedElements = _libsbml.CompOneListOfReplacedElements
CompLOReplaceElementsAllowedElements = _libsbml.CompLOReplaceElementsAllowedElements
CompLOReplacedElementsAllowedAttribs = _libsbml.CompLOReplacedElementsAllowedAttribs
CompEmptyLOReplacedElements = _libsbml.CompEmptyLOReplacedElements
CompOneReplacedByElement = _libsbml.CompOneReplacedByElement
CompAttributeRequiredMissing = _libsbml.CompAttributeRequiredMissing
CompAttributeRequiredMustBeBoolean = _libsbml.CompAttributeRequiredMustBeBoolean
CompRequiredTrueIfElementsRemain = _libsbml.CompRequiredTrueIfElementsRemain
CompRequiredFalseIfAllElementsReplaced = _libsbml.CompRequiredFalseIfAllElementsReplaced
CompOneListOfModelDefinitions = _libsbml.CompOneListOfModelDefinitions
CompEmptyLOModelDefs = _libsbml.CompEmptyLOModelDefs
CompLOModelDefsAllowedElements = _libsbml.CompLOModelDefsAllowedElements
CompLOExtModelDefsAllowedElements = _libsbml.CompLOExtModelDefsAllowedElements
CompLOModelDefsAllowedAttributes = _libsbml.CompLOModelDefsAllowedAttributes
CompLOExtModDefsAllowedAttributes = _libsbml.CompLOExtModDefsAllowedAttributes
CompOneListOfExtModelDefinitions = _libsbml.CompOneListOfExtModelDefinitions
CompAttributeRequiredMustBeTrue = _libsbml.CompAttributeRequiredMustBeTrue
CompExtModDefAllowedCoreAttributes = _libsbml.CompExtModDefAllowedCoreAttributes
CompExtModDefAllowedElements = _libsbml.CompExtModDefAllowedElements
CompExtModDefAllowedAttributes = _libsbml.CompExtModDefAllowedAttributes
CompReferenceMustBeL3 = _libsbml.CompReferenceMustBeL3
CompModReferenceMustIdOfModel = _libsbml.CompModReferenceMustIdOfModel
CompExtModMd5DoesNotMatch = _libsbml.CompExtModMd5DoesNotMatch
CompInvalidSourceSyntax = _libsbml.CompInvalidSourceSyntax
CompInvalidModelRefSyntax = _libsbml.CompInvalidModelRefSyntax
CompInvalidMD5Syntax = _libsbml.CompInvalidMD5Syntax
CompCircularExternalModelReference = _libsbml.CompCircularExternalModelReference
CompOneListOfOnModel = _libsbml.CompOneListOfOnModel
CompNoEmptyListOfOnModel = _libsbml.CompNoEmptyListOfOnModel
CompLOSubmodelsAllowedElements = _libsbml.CompLOSubmodelsAllowedElements
CompLOPortsAllowedElements = _libsbml.CompLOPortsAllowedElements
CompLOSubmodelsAllowedAttributes = _libsbml.CompLOSubmodelsAllowedAttributes
CompLOPortsAllowedAttributes = _libsbml.CompLOPortsAllowedAttributes
CompSubmodelAllowedCoreAttributes = _libsbml.CompSubmodelAllowedCoreAttributes
CompSubmodelAllowedElements = _libsbml.CompSubmodelAllowedElements
CompOneListOfDeletionOnSubmodel = _libsbml.CompOneListOfDeletionOnSubmodel
CompSubmodelNoEmptyLODeletions = _libsbml.CompSubmodelNoEmptyLODeletions
CompLODeletionsAllowedElements = _libsbml.CompLODeletionsAllowedElements
CompLODeletionAllowedAttributes = _libsbml.CompLODeletionAllowedAttributes
CompSubmodelAllowedAttributes = _libsbml.CompSubmodelAllowedAttributes
CompModReferenceSyntax = _libsbml.CompModReferenceSyntax
CompInvalidTimeConvFactorSyntax = _libsbml.CompInvalidTimeConvFactorSyntax
CompInvalidExtentConvFactorSyntax = _libsbml.CompInvalidExtentConvFactorSyntax
CompSubmodelMustReferenceModel = _libsbml.CompSubmodelMustReferenceModel
CompSubmodelCannotReferenceSelf = _libsbml.CompSubmodelCannotReferenceSelf
CompModCannotCircularlyReferenceSelf = _libsbml.CompModCannotCircularlyReferenceSelf
CompTimeConversionMustBeParameter = _libsbml.CompTimeConversionMustBeParameter
CompExtentConversionMustBeParameter = _libsbml.CompExtentConversionMustBeParameter
CompPortRefMustReferencePort = _libsbml.CompPortRefMustReferencePort
CompIdRefMustReferenceObject = _libsbml.CompIdRefMustReferenceObject
CompUnitRefMustReferenceUnitDef = _libsbml.CompUnitRefMustReferenceUnitDef
CompMetaIdRefMustReferenceObject = _libsbml.CompMetaIdRefMustReferenceObject
CompParentOfSBRefChildMustBeSubmodel = _libsbml.CompParentOfSBRefChildMustBeSubmodel
CompInvalidPortRefSyntax = _libsbml.CompInvalidPortRefSyntax
CompInvalidIdRefSyntax = _libsbml.CompInvalidIdRefSyntax
CompInvalidUnitRefSyntax = _libsbml.CompInvalidUnitRefSyntax
CompInvalidMetaIdRefSyntax = _libsbml.CompInvalidMetaIdRefSyntax
CompOneSBaseRefOnly = _libsbml.CompOneSBaseRefOnly
CompDeprecatedSBaseRefSpelling = _libsbml.CompDeprecatedSBaseRefSpelling
CompSBaseRefMustReferenceObject = _libsbml.CompSBaseRefMustReferenceObject
CompSBaseRefMustReferenceOnlyOneObject = _libsbml.CompSBaseRefMustReferenceOnlyOneObject
CompNoMultipleReferences = _libsbml.CompNoMultipleReferences
CompPortMustReferenceObject = _libsbml.CompPortMustReferenceObject
CompPortMustReferenceOnlyOneObject = _libsbml.CompPortMustReferenceOnlyOneObject
CompPortAllowedAttributes = _libsbml.CompPortAllowedAttributes
CompPortReferencesUnique = _libsbml.CompPortReferencesUnique
CompDeletionMustReferenceObject = _libsbml.CompDeletionMustReferenceObject
CompDeletionMustReferOnlyOneObject = _libsbml.CompDeletionMustReferOnlyOneObject
CompDeletionAllowedAttributes = _libsbml.CompDeletionAllowedAttributes
CompReplacedElementMustRefObject = _libsbml.CompReplacedElementMustRefObject
CompReplacedElementMustRefOnlyOne = _libsbml.CompReplacedElementMustRefOnlyOne
CompReplacedElementAllowedAttributes = _libsbml.CompReplacedElementAllowedAttributes
CompReplacedElementSubModelRef = _libsbml.CompReplacedElementSubModelRef
CompReplacedElementDeletionRef = _libsbml.CompReplacedElementDeletionRef
CompReplacedElementConvFactorRef = _libsbml.CompReplacedElementConvFactorRef
CompReplacedElementSameReference = _libsbml.CompReplacedElementSameReference
CompReplacedElementNoDelAndConvFact = _libsbml.CompReplacedElementNoDelAndConvFact
CompReplacedByMustRefObject = _libsbml.CompReplacedByMustRefObject
CompReplacedByMustRefOnlyOne = _libsbml.CompReplacedByMustRefOnlyOne
CompReplacedByAllowedAttributes = _libsbml.CompReplacedByAllowedAttributes
CompReplacedBySubModelRef = _libsbml.CompReplacedBySubModelRef
CompMustReplaceSameClass = _libsbml.CompMustReplaceSameClass
CompMustReplaceIDs = _libsbml.CompMustReplaceIDs
CompMustReplaceMetaIDs = _libsbml.CompMustReplaceMetaIDs
CompMustReplacePackageIDs = _libsbml.CompMustReplacePackageIDs
CompUnresolvedReference = _libsbml.CompUnresolvedReference
CompNoModelInReference = _libsbml.CompNoModelInReference
CompExtModDefBad = _libsbml.CompExtModDefBad
CompModelFlatteningFailed = _libsbml.CompModelFlatteningFailed
CompFlatModelNotValid = _libsbml.CompFlatModelNotValid
CompLineNumbersUnreliable = _libsbml.CompLineNumbersUnreliable
CompFlatteningNotRecognisedReqd = _libsbml.CompFlatteningNotRecognisedReqd
CompFlatteningNotRecognisedNotReqd = _libsbml.CompFlatteningNotRecognisedNotReqd
CompFlatteningNotImplementedNotReqd = _libsbml.CompFlatteningNotImplementedNotReqd
CompFlatteningNotImplementedReqd = _libsbml.CompFlatteningNotImplementedReqd
CompFlatteningWarning = _libsbml.CompFlatteningWarning
CompDeprecatedDeleteFunction = _libsbml.CompDeprecatedDeleteFunction
CompDeprecatedReplaceFunction = _libsbml.CompDeprecatedReplaceFunction
CompDeletedReplacement = _libsbml.CompDeletedReplacement
CompIdRefMayReferenceUnknownPackage = _libsbml.CompIdRefMayReferenceUnknownPackage
CompMetaIdRefMayReferenceUnknownPkg = _libsbml.CompMetaIdRefMayReferenceUnknownPkg
class CompPkgNamespaces(SBMLNamespaces):
    """

    Set of SBML Level + Version + namespace triples.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    SBMLExtensionNamespaces is a template class.  It is extended from
    SBMLNamespaces and is meant to be used by package extensions to store
    the SBML Level, Version within a Level, and package version of the
    SBML Level 3 package implemented by a libSBML package extension.

    Basic principles of SBML package extensions in libSBML
    ======================================================================

    SBML Level 3's package structure permits modular extensions to the
    core SBML format.  In libSBML, support for SBML Level 3 packages is
    provided through optional package extensions that can be plugged into
    libSBML at the time it is built/compiled.  Users of libSBML can thus
    choose which extensions are enabled in their software applications.

    LibSBML defines a number of classes that developers of package
    extensions can use to implement support for an SBML Level 3 package.
    These classes make it easier to extend libSBML objects with new
    attributes and/or subobjects as needed by a particular Level 3
    package. Three overall categories of classes make up libSBML's
    facilities for implementing package extensions.  There are (1) classes
    that serve as base classes meant to be subclassed, (2) template
    classes meant to be instantiated rather than subclassed, and (3)
    support classes that provide utility features. A given package
    implementation for libSBML will take the form of code using these and
    other libSBML classes, placed in a subdirectory of src/sbml/packages/.

    The basic libSBML distribution includes a number of package extensions
    implementing support for officially-endorsed SBML Level 3 packages;
    among these are Flux Balance Constraints ('fbc'), Hierarchical Model
    Composition ('comp'), Layout ('layout'), and Qualitative Models
    ('qual').  They can serve as working examples for developers working
    to implement other packages.

    Extensions in libSBML can currently only be implemented in C++ or C;
    there is no mechanism to implement them first in languages such as
    Java or Python.  However, once implemented in C++ or C, language
    interfaces can be generated semi-automatically using the framework in
    place in libSBML.  (The approach is based on using SWIG and facilities
    in libSBML's build system.)

    """

    __swig_setmethods__ = {}
    for _s in [SBMLNamespaces]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CompPkgNamespaces, name, value)
    __swig_getmethods__ = {}
    for _s in [SBMLNamespaces]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CompPkgNamespaces, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_CompPkgNamespaces
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(SBMLExtensionNamespaces<(CompExtension)> self, unsigned int level, unsigned int version, unsigned int pkgVersion, string prefix) -> CompPkgNamespaces
        __init__(SBMLExtensionNamespaces<(CompExtension)> self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> CompPkgNamespaces
        __init__(SBMLExtensionNamespaces<(CompExtension)> self, unsigned int level, unsigned int version) -> CompPkgNamespaces
        __init__(SBMLExtensionNamespaces<(CompExtension)> self, unsigned int level) -> CompPkgNamespaces
        __init__(SBMLExtensionNamespaces<(CompExtension)> self) -> CompPkgNamespaces
        __init__(SBMLExtensionNamespaces<(CompExtension)> self, CompPkgNamespaces orig) -> CompPkgNamespaces


        Set of SBML Level + Version + namespace triples.

        This class of objects is defined by libSBML only and has no direct
        equivalent in terms of SBML components.  This class is not prescribed
        by the SBML specifications, although it is used to implement features
        defined in SBML.

        SBMLExtensionNamespaces is a template class.  It is extended from
        SBMLNamespaces and is meant to be used by package extensions to store
        the SBML Level, Version within a Level, and package version of the
        SBML Level 3 package implemented by a libSBML package extension.

        Basic principles of SBML package extensions in libSBML
        ======================================================================

        SBML Level 3's package structure permits modular extensions to the
        core SBML format.  In libSBML, support for SBML Level 3 packages is
        provided through optional package extensions that can be plugged into
        libSBML at the time it is built/compiled.  Users of libSBML can thus
        choose which extensions are enabled in their software applications.

        LibSBML defines a number of classes that developers of package
        extensions can use to implement support for an SBML Level 3 package.
        These classes make it easier to extend libSBML objects with new
        attributes and/or subobjects as needed by a particular Level 3
        package. Three overall categories of classes make up libSBML's
        facilities for implementing package extensions.  There are (1) classes
        that serve as base classes meant to be subclassed, (2) template
        classes meant to be instantiated rather than subclassed, and (3)
        support classes that provide utility features. A given package
        implementation for libSBML will take the form of code using these and
        other libSBML classes, placed in a subdirectory of src/sbml/packages/.

        The basic libSBML distribution includes a number of package extensions
        implementing support for officially-endorsed SBML Level 3 packages;
        among these are Flux Balance Constraints ('fbc'), Hierarchical Model
        Composition ('comp'), Layout ('layout'), and Qualitative Models
        ('qual').  They can serve as working examples for developers working
        to implement other packages.

        Extensions in libSBML can currently only be implemented in C++ or C;
        there is no mechanism to implement them first in languages such as
        Java or Python.  However, once implemented in C++ or C, language
        interfaces can be generated semi-automatically using the framework in
        place in libSBML.  (The approach is based on using SWIG and facilities
        in libSBML's build system.)

        """
        this = _libsbml.new_CompPkgNamespaces(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(CompPkgNamespaces self) -> ISBMLExtensionNamespaces


        Creates and returns a deep copy of this SBMLNamespaces object.

        Returns the (deep) copy of this SBMLNamespaces object.

        """
        return _libsbml.CompPkgNamespaces_clone(self)


    def getURI(self):
        """
        getURI(CompPkgNamespaces self) -> string


        Returns a string representing the SBML XML namespace of this object.

        Returns a string representing the SBML namespace that reflects the
        SBML Level and Version of this object.

        """
        return _libsbml.CompPkgNamespaces_getURI(self)


    def getPackageVersion(self):
        """getPackageVersion(CompPkgNamespaces self) -> unsigned int"""
        return _libsbml.CompPkgNamespaces_getPackageVersion(self)


    def getPackageName(self):
        """
        getPackageName(CompPkgNamespaces self) -> string


        Returns the name of the main package for this namespace.

        Returns the name of the main package for this namespace. 'core' will
        be returned if this namespace is defined in the SBML  core.

        """
        return _libsbml.CompPkgNamespaces_getPackageName(self)

CompPkgNamespaces_swigregister = _libsbml.CompPkgNamespaces_swigregister
CompPkgNamespaces_swigregister(CompPkgNamespaces)

class FbcPkgNamespaces(SBMLNamespaces):
    """

    Set of SBML Level + Version + namespace triples.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    SBMLExtensionNamespaces is a template class.  It is extended from
    SBMLNamespaces and is meant to be used by package extensions to store
    the SBML Level, Version within a Level, and package version of the
    SBML Level 3 package implemented by a libSBML package extension.

    Basic principles of SBML package extensions in libSBML
    ======================================================================

    SBML Level 3's package structure permits modular extensions to the
    core SBML format.  In libSBML, support for SBML Level 3 packages is
    provided through optional package extensions that can be plugged into
    libSBML at the time it is built/compiled.  Users of libSBML can thus
    choose which extensions are enabled in their software applications.

    LibSBML defines a number of classes that developers of package
    extensions can use to implement support for an SBML Level 3 package.
    These classes make it easier to extend libSBML objects with new
    attributes and/or subobjects as needed by a particular Level 3
    package. Three overall categories of classes make up libSBML's
    facilities for implementing package extensions.  There are (1) classes
    that serve as base classes meant to be subclassed, (2) template
    classes meant to be instantiated rather than subclassed, and (3)
    support classes that provide utility features. A given package
    implementation for libSBML will take the form of code using these and
    other libSBML classes, placed in a subdirectory of src/sbml/packages/.

    The basic libSBML distribution includes a number of package extensions
    implementing support for officially-endorsed SBML Level 3 packages;
    among these are Flux Balance Constraints ('fbc'), Hierarchical Model
    Composition ('comp'), Layout ('layout'), and Qualitative Models
    ('qual').  They can serve as working examples for developers working
    to implement other packages.

    Extensions in libSBML can currently only be implemented in C++ or C;
    there is no mechanism to implement them first in languages such as
    Java or Python.  However, once implemented in C++ or C, language
    interfaces can be generated semi-automatically using the framework in
    place in libSBML.  (The approach is based on using SWIG and facilities
    in libSBML's build system.)

    """

    __swig_setmethods__ = {}
    for _s in [SBMLNamespaces]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FbcPkgNamespaces, name, value)
    __swig_getmethods__ = {}
    for _s in [SBMLNamespaces]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, FbcPkgNamespaces, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_FbcPkgNamespaces
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(SBMLExtensionNamespaces<(FbcExtension)> self, unsigned int level, unsigned int version, unsigned int pkgVersion, string prefix) -> FbcPkgNamespaces
        __init__(SBMLExtensionNamespaces<(FbcExtension)> self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> FbcPkgNamespaces
        __init__(SBMLExtensionNamespaces<(FbcExtension)> self, unsigned int level, unsigned int version) -> FbcPkgNamespaces
        __init__(SBMLExtensionNamespaces<(FbcExtension)> self, unsigned int level) -> FbcPkgNamespaces
        __init__(SBMLExtensionNamespaces<(FbcExtension)> self) -> FbcPkgNamespaces
        __init__(SBMLExtensionNamespaces<(FbcExtension)> self, FbcPkgNamespaces orig) -> FbcPkgNamespaces


        Set of SBML Level + Version + namespace triples.

        This class of objects is defined by libSBML only and has no direct
        equivalent in terms of SBML components.  This class is not prescribed
        by the SBML specifications, although it is used to implement features
        defined in SBML.

        SBMLExtensionNamespaces is a template class.  It is extended from
        SBMLNamespaces and is meant to be used by package extensions to store
        the SBML Level, Version within a Level, and package version of the
        SBML Level 3 package implemented by a libSBML package extension.

        Basic principles of SBML package extensions in libSBML
        ======================================================================

        SBML Level 3's package structure permits modular extensions to the
        core SBML format.  In libSBML, support for SBML Level 3 packages is
        provided through optional package extensions that can be plugged into
        libSBML at the time it is built/compiled.  Users of libSBML can thus
        choose which extensions are enabled in their software applications.

        LibSBML defines a number of classes that developers of package
        extensions can use to implement support for an SBML Level 3 package.
        These classes make it easier to extend libSBML objects with new
        attributes and/or subobjects as needed by a particular Level 3
        package. Three overall categories of classes make up libSBML's
        facilities for implementing package extensions.  There are (1) classes
        that serve as base classes meant to be subclassed, (2) template
        classes meant to be instantiated rather than subclassed, and (3)
        support classes that provide utility features. A given package
        implementation for libSBML will take the form of code using these and
        other libSBML classes, placed in a subdirectory of src/sbml/packages/.

        The basic libSBML distribution includes a number of package extensions
        implementing support for officially-endorsed SBML Level 3 packages;
        among these are Flux Balance Constraints ('fbc'), Hierarchical Model
        Composition ('comp'), Layout ('layout'), and Qualitative Models
        ('qual').  They can serve as working examples for developers working
        to implement other packages.

        Extensions in libSBML can currently only be implemented in C++ or C;
        there is no mechanism to implement them first in languages such as
        Java or Python.  However, once implemented in C++ or C, language
        interfaces can be generated semi-automatically using the framework in
        place in libSBML.  (The approach is based on using SWIG and facilities
        in libSBML's build system.)

        """
        this = _libsbml.new_FbcPkgNamespaces(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(FbcPkgNamespaces self) -> ISBMLExtensionNamespaces


        Creates and returns a deep copy of this SBMLNamespaces object.

        Returns the (deep) copy of this SBMLNamespaces object.

        """
        return _libsbml.FbcPkgNamespaces_clone(self)


    def getURI(self):
        """
        getURI(FbcPkgNamespaces self) -> string


        Returns a string representing the SBML XML namespace of this object.

        Returns a string representing the SBML namespace that reflects the
        SBML Level and Version of this object.

        """
        return _libsbml.FbcPkgNamespaces_getURI(self)


    def getPackageVersion(self):
        """getPackageVersion(FbcPkgNamespaces self) -> unsigned int"""
        return _libsbml.FbcPkgNamespaces_getPackageVersion(self)


    def getPackageName(self):
        """
        getPackageName(FbcPkgNamespaces self) -> string


        Returns the name of the main package for this namespace.

        Returns the name of the main package for this namespace. 'core' will
        be returned if this namespace is defined in the SBML  core.

        """
        return _libsbml.FbcPkgNamespaces_getPackageName(self)

FbcPkgNamespaces_swigregister = _libsbml.FbcPkgNamespaces_swigregister
FbcPkgNamespaces_swigregister(FbcPkgNamespaces)

class FbcExtension(SBMLExtension):
    """

    [SBML 'fbc' package]  Base extension class for the "fbc" package.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    """

    __swig_setmethods__ = {}
    for _s in [SBMLExtension]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FbcExtension, name, value)
    __swig_getmethods__ = {}
    for _s in [SBMLExtension]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, FbcExtension, name)
    __repr__ = _swig_repr

    def getPackageName():
        """
        getPackageName() -> string


        Returns the nickname of the SBML Level 3 package implemented by this
        libSBML extension.

        Returns the package nickname, as a string.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.FbcExtension_getPackageName()

    getPackageName = staticmethod(getPackageName)

    def getDefaultLevel():
        """
        getDefaultLevel() -> unsigned int


        Returns the default SBML Level used by this libSBML package extension.

        Returns the SBML Level.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.FbcExtension_getDefaultLevel()

    getDefaultLevel = staticmethod(getDefaultLevel)

    def getDefaultVersion():
        """
        getDefaultVersion() -> unsigned int


        Returns the default SBML Version used by this libSBML package
        extension.

        Returns the Version within the default SBML Level.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.FbcExtension_getDefaultVersion()

    getDefaultVersion = staticmethod(getDefaultVersion)

    def getDefaultPackageVersion():
        """
        getDefaultPackageVersion() -> unsigned int


        Returns the default version of the SBML Level 3 package implemented by
        this libSBML extension.

        Returns the default version number of the SBML Level 3 package
        definition.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.FbcExtension_getDefaultPackageVersion()

    getDefaultPackageVersion = staticmethod(getDefaultPackageVersion)

    def getXmlnsL3V1V1():
        """
        getXmlnsL3V1V1() -> string


        Returns the XML namespace URI of the SBML Level 3 package implemented
        by this libSBML extension.

        Returns the XML namespace as a string.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.FbcExtension_getXmlnsL3V1V1()

    getXmlnsL3V1V1 = staticmethod(getXmlnsL3V1V1)

    def getXmlnsL3V1V2():
        """
        getXmlnsL3V1V2() -> string


        Returns the XML namespace URI of the SBML Level 3 package implemented
        by this libSBML extension.

        Returns the XML namespace as a string.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.FbcExtension_getXmlnsL3V1V2()

    getXmlnsL3V1V2 = staticmethod(getXmlnsL3V1V2)

    def __init__(self, *args):
        """
        __init__(FbcExtension self) -> FbcExtension
        __init__(FbcExtension self, FbcExtension orig) -> FbcExtension


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            FbcExtension(FbcExtension orig)

        Copy constructor for FbcExtension.

        Parameter 'orig' is the FbcExtension instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            FbcExtension()

        Creates a new FbcExtension instance.

        """
        this = _libsbml.new_FbcExtension(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(FbcExtension self) -> FbcExtension


        Creates and returns a deep copy of this FbcExtension object.

        Returns a (deep) copy of this FbcExtension object.

        """
        return _libsbml.FbcExtension_clone(self)

    __swig_destroy__ = _libsbml.delete_FbcExtension
    __del__ = lambda self: None

    def getName(self):
        """
        getName(FbcExtension self) -> string


        Returns the name of this SBML Level 3 package ('fbc').

        Returns a string representing the name of this package ('fbc').

        """
        return _libsbml.FbcExtension_getName(self)


    def getURI(self, sbmlLevel, sbmlVersion, pkgVersion):
        """
        getURI(FbcExtension self, unsigned int sbmlLevel, unsigned int sbmlVersion, unsigned int pkgVersion) -> string


        Returns a string representing the SBML XML namespace of this SBML
        Level 3 package.

        The namespace URI constructed by this method corresponds to the
        combination of the Level and Version of SBML, and the Version of the
        SBML Level 3 package.  (At the time of this writing, the only SBML
        Level that supports packages is Level 3, so the value of 'sbmlLevel'
        must necessarily always be 3.)

        Parameter 'sbmlLevel' is the level of SBML. Parameter 'sbmlVersion' is
        the version of SBML. Parameter 'pkgVersion' is the version of the
        package.

        Returns a string representing the package URI, or an empty string if
        no corresponding URI exists.

        """
        return _libsbml.FbcExtension_getURI(self, sbmlLevel, sbmlVersion, pkgVersion)


    def getLevel(self, uri):
        """
        getLevel(FbcExtension self, string uri) -> unsigned int


        Returns the SBML Level for the given URI of this package.

        Parameter 'uri' is a URI that represents a version of this package.

        Returns the SBML Level for the given URI of this package, or '0' if
        the given URI is invalid, or for a different package.

        """
        return _libsbml.FbcExtension_getLevel(self, uri)


    def getVersion(self, uri):
        """
        getVersion(FbcExtension self, string uri) -> unsigned int


        Returns the Version within the SBML Level for the given URI of this
        package.

        Parameter 'uri' is a URI that represents a version of this package.

        Returns the SBML Version within the SBML Level for the given URI of
        this package, or '0' if the given URI is invalid, or for a different
        package.

        """
        return _libsbml.FbcExtension_getVersion(self, uri)


    def getPackageVersion(self, uri):
        """
        getPackageVersion(FbcExtension self, string uri) -> unsigned int


        Returns the SBML Level 3 package version for the given URI of this
        package.

        Parameter 'uri' is a URI that represents one of the valid versions of
        this package.

        Returns the version of the SBML Level 3 package with the given URI, or
        '0' if the given URI is invalid, or for a different package.

        """
        return _libsbml.FbcExtension_getPackageVersion(self, uri)


    def getSBMLExtensionNamespaces(self, uri):
        """
        getSBMLExtensionNamespaces(FbcExtension self, string uri) -> SBMLNamespaces


        Returns an FbcPkgNamespaces object.

        Parameter 'uri' is a URI that represents one of the valid versions of
        the "fbc" package.

        Returns an FbcPkgNamespaces object corresponding to the given 'uri',
        or 'None' if the URI is not defined in the "fbc" package.

        """
        return _libsbml.FbcExtension_getSBMLExtensionNamespaces(self, uri)


    def getStringFromTypeCode(self, typeCode):
        """
        getStringFromTypeCode(FbcExtension self, int typeCode) -> char const *


        Takes a type code of the "fbc" package and returns a string
        describing the code.

        Parameter 'typeCode' is a libSBML type code defined by the libSBML
        extension implementing support for the SBML Level 3 "fbc" package.

        Returns a text string representing the type code given by 'typeCode'.
        If the type code is unrecognized for this implementation of the
        libSBML "fbc" package, the string returned will be '(Unknown SBML
        Fbc Type)'.

        """
        return _libsbml.FbcExtension_getStringFromTypeCode(self, typeCode)


    def init():
        """
        init()


        Internal implementation method.

        """
        return _libsbml.FbcExtension_init()

    init = staticmethod(init)

    def getErrorTableV2(self, index):
        """
        getErrorTableV2(FbcExtension self, unsigned int index) -> packageErrorTableEntryV2


        Internal implementation method.

        """
        return _libsbml.FbcExtension_getErrorTableV2(self, index)


    def getErrorTableIndex(self, errorId):
        """
        getErrorTableIndex(FbcExtension self, unsigned int errorId) -> unsigned int


        Internal implementation method.

        """
        return _libsbml.FbcExtension_getErrorTableIndex(self, errorId)


    def getErrorIdOffset(self):
        """
        getErrorIdOffset(FbcExtension self) -> unsigned int


        Internal implementation method.

        """
        return _libsbml.FbcExtension_getErrorIdOffset(self)


    def hasMutiplePackageVersions(self):
        """
        hasMutiplePackageVersions(FbcExtension self) -> bool


        Internal implementation method.

        """
        return _libsbml.FbcExtension_hasMutiplePackageVersions(self)

FbcExtension_swigregister = _libsbml.FbcExtension_swigregister
FbcExtension_swigregister(FbcExtension)

def FbcExtension_getPackageName():
    """
    FbcExtension_getPackageName() -> string


    Returns the nickname of the SBML Level 3 package implemented by this
    libSBML extension.

    Returns the package nickname, as a string.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.FbcExtension_getPackageName()

def FbcExtension_getDefaultLevel():
    """
    FbcExtension_getDefaultLevel() -> unsigned int


    Returns the default SBML Level used by this libSBML package extension.

    Returns the SBML Level.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.FbcExtension_getDefaultLevel()

def FbcExtension_getDefaultVersion():
    """
    FbcExtension_getDefaultVersion() -> unsigned int


    Returns the default SBML Version used by this libSBML package
    extension.

    Returns the Version within the default SBML Level.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.FbcExtension_getDefaultVersion()

def FbcExtension_getDefaultPackageVersion():
    """
    FbcExtension_getDefaultPackageVersion() -> unsigned int


    Returns the default version of the SBML Level 3 package implemented by
    this libSBML extension.

    Returns the default version number of the SBML Level 3 package
    definition.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.FbcExtension_getDefaultPackageVersion()

def FbcExtension_getXmlnsL3V1V1():
    """
    FbcExtension_getXmlnsL3V1V1() -> string


    Returns the XML namespace URI of the SBML Level 3 package implemented
    by this libSBML extension.

    Returns the XML namespace as a string.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.FbcExtension_getXmlnsL3V1V1()

def FbcExtension_getXmlnsL3V1V2():
    """
    FbcExtension_getXmlnsL3V1V2() -> string


    Returns the XML namespace URI of the SBML Level 3 package implemented
    by this libSBML extension.

    Returns the XML namespace as a string.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.FbcExtension_getXmlnsL3V1V2()

def FbcExtension_init():
    """
    FbcExtension_init()


    Internal implementation method.

    """
    return _libsbml.FbcExtension_init()

SBML_FBC_V1ASSOCIATION = _libsbml.SBML_FBC_V1ASSOCIATION
SBML_FBC_FLUXBOUND = _libsbml.SBML_FBC_FLUXBOUND
SBML_FBC_FLUXOBJECTIVE = _libsbml.SBML_FBC_FLUXOBJECTIVE
SBML_FBC_GENEASSOCIATION = _libsbml.SBML_FBC_GENEASSOCIATION
SBML_FBC_OBJECTIVE = _libsbml.SBML_FBC_OBJECTIVE
SBML_FBC_ASSOCIATION = _libsbml.SBML_FBC_ASSOCIATION
SBML_FBC_GENEPRODUCTASSOCIATION = _libsbml.SBML_FBC_GENEPRODUCTASSOCIATION
SBML_FBC_GENEPRODUCT = _libsbml.SBML_FBC_GENEPRODUCT
SBML_FBC_GENEPRODUCTREF = _libsbml.SBML_FBC_GENEPRODUCTREF
SBML_FBC_AND = _libsbml.SBML_FBC_AND
SBML_FBC_OR = _libsbml.SBML_FBC_OR
class FbcModelPlugin(SBasePlugin):
    """

    [SBML 'fbc' package]  Extension of Model.

    The FbcModelPlugin object is used to extend the standard SBML Model
    object with features used in the SBML Level 3 Flux Balance Constraints
    ("fbc") package.  In Version 1 of the "fbc" specification, the
    extended Model class has two optional subobjects: ListOfObjectives and
    ListOfFluxBounds.  In Version 2 of the specification, the extended
    Model object is defined differently: it is extended with a new
    required attribute named 'strict', and the two optional subobjects
    ListOfObjectives and ListOfGeneProducts.  (ListOfFluxBounds is not
    used in Version 2.)

    The 'strict' attribute on the (extended) Model class
    ======================================================================

    The mandatory attribute 'strict', of type boolean, in  Version 2 of
    this package, is used to apply an additional set of restrictions to
    the model.  The 'strict' attribute helps ensure that the Flux Balance
    Constraints package can be used to encode legacy flux-balance analysis
    models expressible as Linear Programs (LP's) for software that is
    unable to analyze arbitrary mathematical expressions that may appear
    in an SBML model.  In addition, a 'strict' model is fully described
    and mathematically consistent, for example, by ensuring that all
    fluxes have a valid upper or lower bound.

    The following restrictions are in effect if an "fbc" model object
    has a value of 'true' for the attribute 'strict' on Model:

    * Each Reaction in a Model must define values for the attributes
    'lowerFluxBound' and 'upperFluxBound', with each attribute pointing to
    a valid Parameter object defined in the current Model.

    * Each Parameter object referred to by the Reaction attributes
    'lowerFluxBound' and 'upperFluxBound' must have its 'constant'
    attribute set to the value 'true' and its 'value' attribute set to a
    value of type double.  This value may not be 'NaN'.

    * SpeciesReference objects in Reaction objects must have their
    'stoichiometry' attribute set to a double value that is not 'NaN', nor
    '-INF', nor 'INF'. In addition, the value of their 'constant'
    attribute must be set to 'true'.

    * InitialAssignment objects may not target the Parameter objects
    referenced by the Reaction attributes 'lowerFluxBound' and
    'upperFluxBound', nor any SpeciesReference objects.

    * All defined FluxObjective objects must have their coefficient
    attribute set to a double value that is not 'NaN', nor '-INF', nor
    'INF'.

    * A Reaction 'lowerFluxBound' attribute may not point to a
    Parameter object that has a value of 'INF'.

    * A Reaction 'upperFluxBound' attribute may not point to a
    Parameter object that has a value of '-INF'.

    * For all Reaction objects, the value of a 'lowerFluxBound'
    attribute must be less than or equal to the value of the
    'upperFluxBound' attribute.

    While it is not compulsory for a 'strict' Flux Balance Constraints
    model to define an Objective, doing so does does allow the model to be
    formulated as a Linear Program and optimized.  However, this decision
    is left to the modeler.  Note that all other properties of the objects
    referred to in the list above are to be set as specified in the
    relevant SBML Level 3 Version 1 Core and Flux Balance Constraints
    ("fbc") specifications.

    Alternatively, if the value of the strict attribute is 'false', then
    none of these restrictions apply and the model creator can choose to
    define "fbc" models that are not necessarily encodable as an LP.
    For example, if strict is 'false', the InitialAssignment construct may
    be used to set any valid numerical entity, including Parameter values
    and stoichiometric coefficients, with any value of type double.  In
    addition, Parameter elements are no longer required to be flagged as
    constant, thus allowing for a Flux Balance Constraints model's use in
    alternative, hybrid modeling strategies.

    Lists of subobjects on the (extended) Model class
    ======================================================================

    The ListOfObjectives is used to define the objectives of a given
    "fbc" model.  Objectives generally consist of linear combinations of
    model variables (fluxes) and a direction for the optimality constraint
    (either maximization or minimization).  Each Objective has a
    ListOfFluxObjectives subobjects.

    In Version 2 of "fbc", the ListOfGeneProducts is used to define the
    gene products represented by the "fbc" model.

    In Version 1 of "fbc", there is no ListOfGeneProducts, and instead,
    Model can have an optional ListOfFluxBounds.

    See also Objective, FluxObjective, FluxBound.

    """

    __swig_setmethods__ = {}
    for _s in [SBasePlugin]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FbcModelPlugin, name, value)
    __swig_getmethods__ = {}
    for _s in [SBasePlugin]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, FbcModelPlugin, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(FbcModelPlugin self, string uri, string prefix, FbcPkgNamespaces fbcns) -> FbcModelPlugin
        __init__(FbcModelPlugin self, FbcModelPlugin orig) -> FbcModelPlugin


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            FbcModelPlugin(FbcModelPlugin orig)

        Copy constructor for FbcModelPlugin.

        Parameter 'orig' is the FbcModelPlugin instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            FbcModelPlugin(string uri, string prefix, FbcPkgNamespaces
        fbcns)

        Creates a new FbcModelPlugin object using the given parameters.

        In the XML representation of an SBML document, XML namespaces are
        used to identify the origin of each XML construct used.  XML
        namespaces are identified by their unique resource identifiers (URIs).
        The core SBML specifications stipulate the namespaces that must be
        used for core SBML constructs; for example, all XML elements that
        belong to SBML Level 3 Version 1 Core must be placed in the XML
        namespace identified by the URI
        'http://www.sbml.org/sbml/level3/version1/core'.  Individual SBML
        Level 3 packages define their own XML namespaces; for example, all
        elements belonging to the SBML Level 3 Layout Version 1 package must
        be placed in the XML namespace
        'http://www.sbml.org/sbml/level3/version1/layout/version1/'.

        The SBMLNamespaces object encapsulates SBML Level/Version/namespaces
        information.  It is used to communicate the SBML Level, Version, and
        (in Level 3) packages used in addition to SBML Level 3 Core.  A common
        approach to using libSBML's SBMLNamespaces facilities is to create an
        SBMLNamespaces object somewhere in a program once, then hand that
        object as needed to object constructors that accept SBMLNamespaces as
        arguments.

        Parameter 'uri' is the URI of the SBML Level 3 package implemented by
        this libSBML package extension.

        Parameter 'prefix' is the XML namespace prefix being used for the
        package.

        Parameter 'fbcns' is the namespaces object for the package.

        """
        this = _libsbml.new_FbcModelPlugin(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(FbcModelPlugin self) -> FbcModelPlugin


        Creates and returns a deep copy of this FbcModelPlugin object.

        Returns a (deep) copy of this FbcModelPlugin object.

        """
        return _libsbml.FbcModelPlugin_clone(self)

    __swig_destroy__ = _libsbml.delete_FbcModelPlugin
    __del__ = lambda self: None

    def createObject(self, stream):
        """
        createObject(FbcModelPlugin self, XMLInputStream stream) -> SBase


        Internal implementation method.

        """
        return _libsbml.FbcModelPlugin_createObject(self, stream)


    def appendFrom(self, model):
        """
        appendFrom(FbcModelPlugin self, Model model) -> int


        Internal implementation method.

        """
        return _libsbml.FbcModelPlugin_appendFrom(self, model)


    def readOtherXML(self, parentObject, stream):
        """
        readOtherXML(FbcModelPlugin self, SBase parentObject, XMLInputStream stream) -> bool


        Internal implementation method.

        """
        return _libsbml.FbcModelPlugin_readOtherXML(self, parentObject, stream)


    def addExpectedAttributes(self, attributes):
        """
        addExpectedAttributes(FbcModelPlugin self, ExpectedAttributes & attributes)


        Internal implementation method.

        """
        return _libsbml.FbcModelPlugin_addExpectedAttributes(self, attributes)


    def readAttributes(self, attributes, expectedAttributes):
        """
        readAttributes(FbcModelPlugin self, XMLAttributes attributes, ExpectedAttributes const & expectedAttributes)


        Internal implementation method.

        """
        return _libsbml.FbcModelPlugin_readAttributes(self, attributes, expectedAttributes)


    def writeAttributes(self, stream):
        """
        writeAttributes(FbcModelPlugin self, XMLOutputStream stream)


        Internal implementation method.

        """
        return _libsbml.FbcModelPlugin_writeAttributes(self, stream)


    def getStrict(self):
        """
        getStrict(FbcModelPlugin self) -> bool


        Returns the value of the 'strict' attribute of this FbcModelPlugin.

        Note: The 'strict' attribute of the FbcModelPlugin is only defined for
        version 2 of the 'Flux Balance Constraints' specification, and has no
        equivalent in version 1 of the specification.

        Returns the value of the 'strict' attribute of this FbcModelPlugin as
        a boolean.

        """
        return _libsbml.FbcModelPlugin_getStrict(self)


    def isSetStrict(self):
        """
        isSetStrict(FbcModelPlugin self) -> bool


        Predicate returning 'True' if this FbcModelPlugin's 'strict' attribute
        is set.

        Note: The 'strict' attribute of the FbcModelPlugin is only defined for
        version 2 of the 'Flux Balance Constraints' specification, and has no
        equivalent in version 1 of the specification.

        Returns 'True' if this FbcModelPlugin's 'strict' attribute has been
        set, otherwise 'False' is returned.

        """
        return _libsbml.FbcModelPlugin_isSetStrict(self)


    def setStrict(self, strict):
        """
        setStrict(FbcModelPlugin self, bool strict) -> int


        Sets the value of the 'strict' attribute of this FbcModelPlugin.

        Note: The 'strict' attribute of the FbcModelPlugin is only defined for
        version 2 of the 'Flux Balance Constraints' specification, and has no
        equivalent in version 1 of the specification.

        Parameter 'strict' is bool value of the 'strict' attribute to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.FbcModelPlugin_setStrict(self, strict)


    def unsetStrict(self):
        """
        unsetStrict(FbcModelPlugin self) -> int


        Unsets the value of the 'strict' attribute of this FbcModelPlugin.

        Note: The 'strict' attribute of the FbcModelPlugin is only defined for
        version 2 of the 'Flux Balance Constraints' specification, and has no
        equivalent in version 1 of the specification.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.FbcModelPlugin_unsetStrict(self)


    def getListOfFluxBounds(self, *args):
        """
        getListOfFluxBounds(FbcModelPlugin self) -> ListOfFluxBounds
        getListOfFluxBounds(FbcModelPlugin self) -> ListOfFluxBounds


        Returns the ListOfFluxBounds in this plugin object.

        Note: FluxBound objects are only defined for version 1 of the 'Flux
        Balance Constraints' specification, and are replaced in version 2 by
        the 'upperFluxBound' and 'lowerFluxBound' attributes of the
        FbcReactionPlugin.

        Returns ListOfFluxBounds object in this plugin object.

        """
        return _libsbml.FbcModelPlugin_getListOfFluxBounds(self, *args)


    def getFluxBound(self, *args):
        """
        getFluxBound(FbcModelPlugin self, unsigned int n) -> FluxBound
        getFluxBound(FbcModelPlugin self, unsigned int n) -> FluxBound
        getFluxBound(FbcModelPlugin self, string sid) -> FluxBound
        getFluxBound(FbcModelPlugin self, string sid) -> FluxBound


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getFluxBound(long n)

        Returns the FluxBound object that belongs to the given index. If the
        index is invalid, 'None' is returned.

        Note: FluxBound objects are only defined for version 1 of the 'Flux
        Balance Constraints' specification, and are replaced in version 2 by
        the 'upperFluxBound' and 'lowerFluxBound' attributes of the
        FbcReactionPlugin.

        Parameter 'n' is the index number of the FluxBound to get.

        Returns the nth FluxBound in the ListOfFluxBounds. If the index 'n' is
        invalid, 'None' is returned.

        ______________________________________________________________________
        Method variant with the following signature:

            getFluxBound(string sid)

        Returns the FluxBound object based on its identifier.

        Note: FluxBound objects are only defined for version 1 of the 'Flux
        Balance Constraints' specification, and are replaced in version 2 by
        the 'upperFluxBound' and 'lowerFluxBound' attributes of the
        FbcReactionPlugin.

        Parameter 'sid' is a string representing the identifier  of the
        FluxBound to get.

        Returns FluxBound in the ListOfFluxBounds with the given 'sid'  or
        'None' if no such FluxBound exists.

        See also getFluxBound(), getListOfFluxBounds().

        """
        return _libsbml.FbcModelPlugin_getFluxBound(self, *args)


    def getFluxBoundsForReaction(self, reaction):
        """
        getFluxBoundsForReaction(FbcModelPlugin self, string reaction) -> ListOfFluxBounds


        Creates a new ListOfFluxBounds object that contains only the
        FluxBound objects associated with the given Reaction.  If no such
        Reaction can be found, or if there are no FluxBound objects associated
        with it, returns None.

        Note: FluxBound objects are only defined for version 1 of the 'Flux
        Balance Constraints' specification, and are replaced in version 2 by
        the 'upperFluxBound' and 'lowerFluxBound' attributes of the
        FbcReactionPlugin.

        Parameter 'reaction' is the id of an reaction to find FluxBound
        objects for.

        Returns a ListOfFluxBounds for the given reaction id.

        """
        return _libsbml.FbcModelPlugin_getFluxBoundsForReaction(self, reaction)


    def addFluxBound(self, bound):
        """
        addFluxBound(FbcModelPlugin self, FluxBound bound) -> int


        Adds a copy of the given FluxBound object to the list of FluxBounds.

        Note: FluxBound objects are only defined for version 1 of the 'Flux
        Balance Constraints' specification, and are replaced in version 2 by
        the 'upperFluxBound' and 'lowerFluxBound' attributes of the
        FbcReactionPlugin.

        Parameter 'bound' is the FluxBound object to be added to the list of
        FluxBounds.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_PKG_VERSION_MISMATCH

        """
        return _libsbml.FbcModelPlugin_addFluxBound(self, bound)


    def createFluxBound(self):
        """
        createFluxBound(FbcModelPlugin self) -> FluxBound


        Creates a new FluxBound object and adds it to the list of FluxBound
        objects and returns it.

        Note: FluxBound objects are only defined for version 1 of the 'Flux
        Balance Constraints' specification, and are replaced in version 2 by
        the 'upperFluxBound' and 'lowerFluxBound' attributes of the
        FbcReactionPlugin.

        Returns a newly created FluxBound object.

        """
        return _libsbml.FbcModelPlugin_createFluxBound(self)


    def removeFluxBound(self, *args):
        """
        removeFluxBound(FbcModelPlugin self, unsigned int n) -> FluxBound
        removeFluxBound(FbcModelPlugin self, string sid) -> FluxBound


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeFluxBound(long n)

        Removes the nth FluxBound object from this plugin object and returns a
        pointer to it.

        The caller owns the returned object and is responsible for deleting
        it.

        Note: FluxBound objects are only defined for version 1 of the 'Flux
        Balance Constraints' specification, and are replaced in version 2 by
        the 'upperFluxBound' and 'lowerFluxBound' attributes of the
        FbcReactionPlugin.

        Parameter 'n' is the index of the FluxBound object to remove.

        Returns the FluxBound object removed.  As mentioned above, the  caller
        owns the returned object. 'None' is returned if the  given index is
        out of range.

        ______________________________________________________________________
        Method variant with the following signature:

            removeFluxBound(string sid)

        Removes the FluxBound object with the given 'sid' attribute from  this
        plugin object and returns a pointer to it.

        The caller owns the returned object and is responsible for deleting
        it.

        Note: FluxBound objects are only defined for version 1 of the 'Flux
        Balance Constraints' specification, and are replaced in version 2 by
        the 'upperFluxBound' and 'lowerFluxBound' attributes of the
        FbcReactionPlugin.

        Parameter 'sid' is the id attribute of the FluxBound object to remove.

        Returns the FluxBound object removed.  As mentioned above, the  caller
        owns the returned object. 'None' is returned if the  given index is
        out of range.

        """
        return _libsbml.FbcModelPlugin_removeFluxBound(self, *args)


    def getNumFluxBounds(self):
        """
        getNumFluxBounds(FbcModelPlugin self) -> unsigned int


        Returns the number of FluxBound object in this plugin object.

        Note: FluxBound objects are only defined for version 1 of the 'Flux
        Balance Constraints' specification, and are replaced in version 2 by
        the 'upperFluxBound' and 'lowerFluxBound' attributes of the
        FbcReactionPlugin.

        Returns the number of FluxBound object in this plugin object.

        """
        return _libsbml.FbcModelPlugin_getNumFluxBounds(self)


    def getListOfObjectives(self, *args):
        """
        getListOfObjectives(FbcModelPlugin self) -> ListOfObjectives
        getListOfObjectives(FbcModelPlugin self) -> ListOfObjectives


        Returns the ListOfObjectives in this FbcModelPlugin object.

        Returns the ListOfObjectives child of this FbcModelPlugin.

        """
        return _libsbml.FbcModelPlugin_getListOfObjectives(self, *args)


    def getObjective(self, *args):
        """
        getObjective(FbcModelPlugin self, unsigned int n) -> Objective
        getObjective(FbcModelPlugin self, unsigned int n) -> Objective
        getObjective(FbcModelPlugin self, string sid) -> Objective
        getObjective(FbcModelPlugin self, string sid) -> Objective


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getObjective(long n)

        Get an Objective from the ListOfObjectives.

        Parameter 'n' is the index number of the Objective to get.

        Returns the nth Objective in the ListOfObjectives within this
        FbcModelPlugin. If the index 'n' is invalid, 'None' is returned.

        See also getNumObjectives().

        ______________________________________________________________________
        Method variant with the following signature:

            getObjective(string sid)

        Get an Objective from the ListOfObjectives based on its identifier.

        Parameter 'sid' is a string representing the identifier of the
        Objective to get.

        Returns the Objective in the ListOfObjectives with the given id or
        'None' if no such Objective exists.

        See also getObjective().

        See also getNumObjectives().

        """
        return _libsbml.FbcModelPlugin_getObjective(self, *args)


    def addObjective(self, o):
        """
        addObjective(FbcModelPlugin self, Objective o) -> int


        Adds a copy the given Objective to this FbcModelPlugin.

        Parameter 'o' is the Objective object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_PKG_VERSION_MISMATCH

        """
        return _libsbml.FbcModelPlugin_addObjective(self, o)


    def getNumObjectives(self):
        """
        getNumObjectives(FbcModelPlugin self) -> unsigned int


        Get the number of Objective objects in this FbcModelPlugin.

        Returns the number of Objective objects in this FbcModelPlugin.

        """
        return _libsbml.FbcModelPlugin_getNumObjectives(self)


    def createObjective(self):
        """
        createObjective(FbcModelPlugin self) -> Objective


        Creates a new Objective object, adds it to this FbcModelPlugin's
        ListOfObjectives and returns the Objective object created.

        Returns a new Objective object instance.

        See also addObjective().

        """
        return _libsbml.FbcModelPlugin_createObjective(self)


    def removeObjective(self, *args):
        """
        removeObjective(FbcModelPlugin self, unsigned int n) -> Objective
        removeObjective(FbcModelPlugin self, string sid) -> Objective


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeObjective(long n)

        Removes the nth Objective from the ListOfObjectives within this
        FbcModelPlugin. and returns a pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the Objective to remove.

        See also getNumObjectives().

        ______________________________________________________________________
        Method variant with the following signature:

            removeObjective(string sid)

        Removes the Objective with the given identifier from the
        ListOfObjectives within this FbcModelPlugin and returns a pointer to
        it.

        The caller owns the returned item and is responsible for deleting it.
        If none of the items in this list have the identifier 'sid', then
        'None' is returned.

        Parameter 'sid' is the identifier of the Objective to remove.

        Returns the Objective removed. As mentioned above, the caller owns the
        returned item.

        """
        return _libsbml.FbcModelPlugin_removeObjective(self, *args)


    def getActiveObjective(self, *args):
        """
        getActiveObjective(FbcModelPlugin self) -> Objective
        getActiveObjective(FbcModelPlugin self) -> Objective


        Returns the current active objective.

        Returns the Objective pointed to by the 'activeObjective'  attribute,
        or 'None' if no such Objective can be found.

        """
        return _libsbml.FbcModelPlugin_getActiveObjective(self, *args)


    def setActiveObjectiveId(self, objectiveId):
        """
        setActiveObjectiveId(FbcModelPlugin self, string objectiveId) -> int


        Sets the id of the active objective.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.FbcModelPlugin_setActiveObjectiveId(self, objectiveId)


    def getActiveObjectiveId(self):
        """
        getActiveObjectiveId(FbcModelPlugin self) -> string


        Returns the id of the current active objective.

        Returns the value of the 'activeObjective' attribute of the
        ListOfObjectives.

        """
        return _libsbml.FbcModelPlugin_getActiveObjectiveId(self)


    def unsetActiveObjectiveId(self):
        """
        unsetActiveObjectiveId(FbcModelPlugin self) -> int


        Unsets the 'activeObjective' attribute of the ListOfObjectives.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        Returns success status

        """
        return _libsbml.FbcModelPlugin_unsetActiveObjectiveId(self)


    def getListOfGeneProducts(self, *args):
        """
        getListOfGeneProducts(FbcModelPlugin self) -> ListOfGeneProducts
        getListOfGeneProducts(FbcModelPlugin self) -> ListOfGeneProducts


        Returns the ListOfGeneProducts in this FbcModelPlugin object.

        Note: GeneProduct objects are only defined for version 2 of the 'Flux
        Balance Constraints' specification, and have no equivalent in version
        1 of the specification.

        Returns the ListOfGeneProducts child of this FbcModelPlugin.

        """
        return _libsbml.FbcModelPlugin_getListOfGeneProducts(self, *args)


    def getGeneProductByLabel(self, label):
        """
        getGeneProductByLabel(FbcModelPlugin self, string label) -> GeneProduct


        Get a GeneProduct from the ListOfGeneProducts based on its label.

        Note: GeneProduct objects are only defined for version 2 of the 'Flux
        Balance Constraints' specification, and have no equivalent in version
        1 of the specification.

        Parameter 'label' is a string representing the label of the
        GeneProduct to get.

        Returns the GeneProduct in the ListOfGeneProducts with the given label
        or 'None' if no such GeneProduct exists.

        See also getGeneProduct().

        See also getNumGeneProducts().

        """
        return _libsbml.FbcModelPlugin_getGeneProductByLabel(self, label)


    def getGeneProduct(self, *args):
        """
        getGeneProduct(FbcModelPlugin self, unsigned int n) -> GeneProduct
        getGeneProduct(FbcModelPlugin self, unsigned int n) -> GeneProduct
        getGeneProduct(FbcModelPlugin self, string sid) -> GeneProduct
        getGeneProduct(FbcModelPlugin self, string sid) -> GeneProduct


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getGeneProduct(long n)

        Get a GeneProduct from the ListOfGeneProducts.

        Note: GeneProduct objects are only defined for version 2 of the 'Flux
        Balance Constraints' specification, and have no equivalent in version
        1 of the specification.

        Parameter 'n' is the index number of the GeneProduct to get.

        Returns the nth GeneProduct in the ListOfGeneProducts within this
        FbcModelPlugin. If the index 'n' is invalid, 'None' is returned.

        See also getNumGeneProducts().

        ______________________________________________________________________
        Method variant with the following signature:

            getGeneProduct(string sid)

        Get a GeneProduct from the ListOfGeneProducts based on its identifier.

        Note: GeneProduct objects are only defined for version 2 of the 'Flux
        Balance Constraints' specification, and have no equivalent in version
        1 of the specification.

        Parameter 'sid' is a string representing the identifier of the
        GeneProduct to get.

        Returns the GeneProduct in the ListOfGeneProducts with the given id or
        'None' if no such GeneProduct exists.

        See also getGeneProduct().

        See also getNumGeneProducts().

        """
        return _libsbml.FbcModelPlugin_getGeneProduct(self, *args)


    def addGeneProduct(self, gp):
        """
        addGeneProduct(FbcModelPlugin self, GeneProduct gp) -> int


        Adds a copy the given GeneProduct to this FbcModelPlugin.

        Note: GeneProduct objects are only defined for version 2 of the 'Flux
        Balance Constraints' specification, and have no equivalent in version
        1 of the specification.

        Parameter 'gp' is the GeneProduct object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_PKG_VERSION_MISMATCH

        """
        return _libsbml.FbcModelPlugin_addGeneProduct(self, gp)


    def getNumGeneProducts(self):
        """
        getNumGeneProducts(FbcModelPlugin self) -> unsigned int


        Get the number of GeneProduct objects in this FbcModelPlugin.

        Note: GeneProduct objects are only defined for version 2 of the 'Flux
        Balance Constraints' specification, and have no equivalent in version
        1 of the specification.

        Returns the number of GeneProduct objects in this FbcModelPlugin.

        """
        return _libsbml.FbcModelPlugin_getNumGeneProducts(self)


    def createGeneProduct(self):
        """
        createGeneProduct(FbcModelPlugin self) -> GeneProduct


        Creates a new GeneProduct object, adds it to this FbcModelPlugin's
        ListOfGeneProducts and returns the GeneProduct object created.

        Note: GeneProduct objects are only defined for version 2 of the 'Flux
        Balance Constraints' specification, and have no equivalent in version
        1 of the specification.

        Returns a new GeneProduct object instance.

        See also addGeneProduct().

        """
        return _libsbml.FbcModelPlugin_createGeneProduct(self)


    def removeGeneProduct(self, *args):
        """
        removeGeneProduct(FbcModelPlugin self, unsigned int n) -> GeneProduct
        removeGeneProduct(FbcModelPlugin self, string sid) -> GeneProduct


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeGeneProduct(long n)

        Removes the nth GeneProduct from the ListOfGeneProducts within this
        FbcModelPlugin. and returns a pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Note: GeneProduct objects are only defined for version 2 of the 'Flux
        Balance Constraints' specification, and have no equivalent in version
        1 of the specification.

        Parameter 'n' is the index of the GeneProduct to remove.

        See also getNumGeneProducts().

        ______________________________________________________________________
        Method variant with the following signature:

            removeGeneProduct(string sid)

        Removes the GeneProduct with the given identifier from the
        ListOfGeneProducts within this FbcModelPlugin and returns a pointer to
        it.

        The caller owns the returned item and is responsible for deleting it.
        If none of the items in this list have the identifier 'sid', then
        'None' is returned.

        Note: GeneProduct objects are only defined for version 2 of the 'Flux
        Balance Constraints' specification, and have no equivalent in version
        1 of the specification.

        Parameter 'sid' is the identifier of the GeneProduct to remove.

        Returns the GeneProduct removed. As mentioned above, the caller owns
        the returned item.

        """
        return _libsbml.FbcModelPlugin_removeGeneProduct(self, *args)


    def getListOfGeneAssociations(self, *args):
        """
        getListOfGeneAssociations(FbcModelPlugin self) -> ListOfGeneAssociations
        getListOfGeneAssociations(FbcModelPlugin self) -> ListOfGeneAssociations


        Returns the ListOfGeneAssociations annotation object for level 1 in
        this plugin object.

        Note: GeneAssociation objects are not defined in any version of the
        'Flux Balance Constraints' specification, and can only be used for
        annotation purposes.  Version 2 instead defines the  GeneProduct and
        GeneProductAssociation classes to cover the information otherwise
        encoded here.

        Returns ListOfGeneAssociations annotation object for level 1 in this
        plugin object.

        """
        return _libsbml.FbcModelPlugin_getListOfGeneAssociations(self, *args)


    def getGeneAssociation(self, *args):
        """
        getGeneAssociation(FbcModelPlugin self, unsigned int n) -> GeneAssociation
        getGeneAssociation(FbcModelPlugin self, unsigned int n) -> GeneAssociation
        getGeneAssociation(FbcModelPlugin self, string sid) -> GeneAssociation
        getGeneAssociation(FbcModelPlugin self, string sid) -> GeneAssociation


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getGeneAssociation(long n)

        Returns the GeneAssociation annotation object that belongs to the
        given index. If the index is invalid, 'None' is returned.

        Note: GeneAssociation objects are not defined in any version of the
        'Flux Balance Constraints' specification, and can only be used for
        annotation purposes.  Version 2 instead defines the  GeneProduct and
        GeneProductAssociation classes to cover the information otherwise
        encoded here.

        Parameter 'n' is the index number of the GeneAssociation annotation to
        get.

        Returns the nth GeneAssociation annotation in the
        ListOfGeneAssociations. If the index 'n' is invalid, 'None' is
        returned.

        ______________________________________________________________________
        Method variant with the following signature:

            getGeneAssociation(string sid)

        Returns the GeneAssociation annotation object based on its identifier.

        Note: GeneAssociation objects are not defined in any version of the
        'Flux Balance Constraints' specification, and can only be used for
        annotation purposes.  Version 2 instead defines the  GeneProduct and
        GeneProductAssociation classes to cover the information otherwise
        encoded here.

        Parameter 'sid' is a string representing the identifier  of the
        GeneAssociation annotation to get.

        Returns GeneAssociation annotation in the ListOfGeneAssociations with
        the given 'sid'  or 'None' if no such GeneAssociation annotation
        exists.

        See also getGeneAssociation(), getListOfGeneAssociations().

        """
        return _libsbml.FbcModelPlugin_getGeneAssociation(self, *args)


    def addGeneAssociation(self, association):
        """
        addGeneAssociation(FbcModelPlugin self, GeneAssociation association) -> int


        Adds a copy of the given GeneAssociation annotation object to the list
        of GeneAssociations.

        Parameter 'association' is the GeneAssociation annotation object to be
        added to the list of GeneAssociations.

        Note: GeneAssociation objects are not defined in any version of the
        'Flux Balance Constraints' specification, and can only be used for
        annotation purposes.  Version 2 instead defines the  GeneProduct and
        GeneProductAssociation classes to cover the information otherwise
        encoded here.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_PKG_VERSION_MISMATCH

        """
        return _libsbml.FbcModelPlugin_addGeneAssociation(self, association)


    def createGeneAssociation(self):
        """
        createGeneAssociation(FbcModelPlugin self) -> GeneAssociation


        Creates a new GeneAssociation annotation object and adds it to the
        list of GeneAssociation objects and returns it.

        Returns a newly created GeneAssociation annotation object.

        """
        return _libsbml.FbcModelPlugin_createGeneAssociation(self)


    def removeGeneAssociation(self, *args):
        """
        removeGeneAssociation(FbcModelPlugin self, unsigned int n) -> GeneAssociation
        removeGeneAssociation(FbcModelPlugin self, string sid) -> GeneAssociation


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeGeneAssociation(long n)

        Removes the nth GeneAssociation annotation object from this plugin
        object and returns a pointer to it.

        The caller owns the returned object and is responsible for deleting
        it.

        Note: GeneAssociation objects are not defined in any version of the
        'Flux Balance Constraints' specification, and can only be used for
        annotation purposes.  Version 2 instead defines the  GeneProduct and
        GeneProductAssociation classes to cover the information otherwise
        encoded here.

        Parameter 'n' is the index of the GeneAssociation annotation object to
        remove.

        Returns the GeneAssociation annotation object removed.  As mentioned
        above, the  caller owns the returned object. 'None' is returned if the
        given index is out of range.

        ______________________________________________________________________
        Method variant with the following signature:

            removeGeneAssociation(string sid)

        Removes the GeneAssociation annotation object with the given 'sid'
        attribute from  this plugin object and returns a pointer to it.

        The caller owns the returned object and is responsible for deleting
        it.

        Note: GeneAssociation objects are not defined in any version of the
        'Flux Balance Constraints' specification, and can only be used for
        annotation purposes.  Version 2 instead defines the  GeneProduct and
        GeneProductAssociation classes to cover the information otherwise
        encoded here.

        Parameter 'sid' is the id attribute of the GeneAssociation annotation
        object to remove.

        Returns the GeneAssociation annotation object removed.  As mentioned
        above, the  caller owns the returned object. 'None' is returned if the
        given index is out of range.

        """
        return _libsbml.FbcModelPlugin_removeGeneAssociation(self, *args)


    def getNumGeneAssociations(self):
        """
        getNumGeneAssociations(FbcModelPlugin self) -> int


        Returns the number of GeneAssociation annotation object in this plugin
        object.

        Note: GeneAssociation objects are not defined in any version of the
        'Flux Balance Constraints' specification, and can only be used for
        annotation purposes.  Version 2 instead defines the  GeneProduct and
        GeneProductAssociation classes to cover the information otherwise
        encoded here.

        Returns the number of GeneAssociation annotation object in this plugin
        object.

        """
        return _libsbml.FbcModelPlugin_getNumGeneAssociations(self)


    def connectToChild(self):
        """
        connectToChild(FbcModelPlugin self)


        Internal implementation method.

        """
        return _libsbml.FbcModelPlugin_connectToChild(self)


    def connectToParent(self, sbase):
        """
        connectToParent(FbcModelPlugin self, SBase sbase)


        Internal implementation method.

        """
        return _libsbml.FbcModelPlugin_connectToParent(self, sbase)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(FbcModelPlugin self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.FbcModelPlugin_enablePackageInternal(self, pkgURI, pkgPrefix, flag)

FbcModelPlugin_swigregister = _libsbml.FbcModelPlugin_swigregister
FbcModelPlugin_swigregister(FbcModelPlugin)

class FbcSpeciesPlugin(SBasePlugin):
    """

    [SBML 'fbc' package]  Extension of Species.

    The FbcSpeciesPlugin class codifies an extension of the core SBML
    Species class defined in the SBML Level 3 Flux Balance Constraints
    ("fbc") package.  The "fbc" package adds two attributes named
    'charge' and 'chemicalFormula' to Species.

    The optional attribute 'charge' can contain a signed integer that
    refers to the Species object's electrical charge (in terms of
    electrons, not the SI unit of coulombs).  Note that this attribute is
    therefore defined as it is in the SBML Level 2 Version 1
    specification.  (The charge attribute was removed in higher Versions
    and Levels of SBML, and is not an attribute of SBML Species in core
    SBML Level 3.  However, it is useful for flux balance constraints
    models, and thus, the Level 3 "fbc" package adds it.)

    The optional attribute 'chemicalFormula' can contain a text string
    that represents the elemental composition of the substance represented
    by the Species object.  The purpose of the 'chemicalFormula' attribute
    is to allow balancing and validating reactions.  This is particularly
    important in constraint-based models.  The format of 'chemicalFormula'
    must consist only of atomic names (as given in the Periodic Table of
    elements) or user-defined compounds, either of which take the form of
    a single capital letter followed by zero or more lowercase letters.
    Where there is more than a single atom present, this is indicated with
    an integer.  With regards to order (and to enhance interoperability of
    models), users are advised to employ the Hill system order. Using this
    notation, the number of carbon atoms in a molecule is indicated first,
    followed by the number of hydrogen atoms, and then the number of all
    other chemical elements in alphabetical order.  When the formula
    contains no carbon, all elements including hydrogen are listed
    alphabetically.

    Here is an example of the XML form of an extended Species definition
    with these attributes:

      <species metaid='meta_M_atp_c' id='M_atp_c' name='ATP' compartment='Cytosol'
      boundaryCondition='false' initialConcentration='0' hasOnlySubstanceUnits='false'
      fbc:charge='-4' fbc:chemicalFormula='C10H12N5O13P3'/>

    """

    __swig_setmethods__ = {}
    for _s in [SBasePlugin]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FbcSpeciesPlugin, name, value)
    __swig_getmethods__ = {}
    for _s in [SBasePlugin]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, FbcSpeciesPlugin, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(FbcSpeciesPlugin self, string uri, string prefix, FbcPkgNamespaces fbcns) -> FbcSpeciesPlugin
        __init__(FbcSpeciesPlugin self, FbcSpeciesPlugin orig) -> FbcSpeciesPlugin


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            FbcSpeciesPlugin(string uri, string prefix, FbcPkgNamespaces
        fbcns)

        Creates a new FbcSpeciesPlugin

        ______________________________________________________________________
        Method variant with the following signature:

            FbcSpeciesPlugin(FbcSpeciesPlugin orig)

        Copy constructor for FbcSpeciesPlugin.

        Parameter 'orig;' is the FbcSpeciesPlugin instance to copy.

        """
        this = _libsbml.new_FbcSpeciesPlugin(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(FbcSpeciesPlugin self) -> FbcSpeciesPlugin


        Creates and returns a deep copy of this FbcSpeciesPlugin object.

        Returns a (deep) copy of this FbcSpeciesPlugin object.

        """
        return _libsbml.FbcSpeciesPlugin_clone(self)

    __swig_destroy__ = _libsbml.delete_FbcSpeciesPlugin
    __del__ = lambda self: None

    def createObject(self, stream):
        """
        createObject(FbcSpeciesPlugin self, XMLInputStream stream) -> SBase


        Internal implementation method.

        """
        return _libsbml.FbcSpeciesPlugin_createObject(self, stream)


    def addExpectedAttributes(self, attributes):
        """
        addExpectedAttributes(FbcSpeciesPlugin self, ExpectedAttributes & attributes)


        Internal implementation method.

        """
        return _libsbml.FbcSpeciesPlugin_addExpectedAttributes(self, attributes)


    def readAttributes(self, attributes, expectedAttributes):
        """
        readAttributes(FbcSpeciesPlugin self, XMLAttributes attributes, ExpectedAttributes const & expectedAttributes)


        Internal implementation method.

        """
        return _libsbml.FbcSpeciesPlugin_readAttributes(self, attributes, expectedAttributes)


    def writeAttributes(self, stream):
        """
        writeAttributes(FbcSpeciesPlugin self, XMLOutputStream stream)


        Internal implementation method.

        """
        return _libsbml.FbcSpeciesPlugin_writeAttributes(self, stream)


    def getCharge(self):
        """
        getCharge(FbcSpeciesPlugin self) -> int


        Returns the value of the 'charge' attribute of this FbcSpeciesPlugin.

        Returns the value of the 'charge' attribute of this FbcSpeciesPlugin
        as a integer.

        """
        return _libsbml.FbcSpeciesPlugin_getCharge(self)


    def getChemicalFormula(self):
        """
        getChemicalFormula(FbcSpeciesPlugin self) -> string


        Returns the value of the 'chemicalFormula' attribute of this
        FbcSpeciesPlugin.

        Returns the value of the 'chemicalFormula' attribute of this
        FbcSpeciesPlugin as a string.

        """
        return _libsbml.FbcSpeciesPlugin_getChemicalFormula(self)


    def isSetCharge(self):
        """
        isSetCharge(FbcSpeciesPlugin self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        FbcSpeciesPlugin's 'charge' attribute has been set.

        Returns 'True' if this FbcSpeciesPlugin's 'charge' attribute has been
        set, otherwise 'False' is returned.

        """
        return _libsbml.FbcSpeciesPlugin_isSetCharge(self)


    def isSetChemicalFormula(self):
        """
        isSetChemicalFormula(FbcSpeciesPlugin self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        FbcSpeciesPlugin's 'chemicalFormula' attribute has been set.

        Returns 'True' if this FbcSpeciesPlugin's 'chemicalFormula' attribute
        has been set, otherwise 'False' is returned.

        """
        return _libsbml.FbcSpeciesPlugin_isSetChemicalFormula(self)


    def setCharge(self, charge):
        """
        setCharge(FbcSpeciesPlugin self, int charge) -> int


        Sets the value of the 'charge' attribute of this FbcSpeciesPlugin.

        Parameter 'charge;' is int value of the 'charge' attribute to be set

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.FbcSpeciesPlugin_setCharge(self, charge)


    def setChemicalFormula(self, chemicalFormula):
        """
        setChemicalFormula(FbcSpeciesPlugin self, string chemicalFormula) -> int


        Sets the value of the 'chemicalFormula' attribute of this
        FbcSpeciesPlugin.

        Parameter 'chemicalFormula;' is string value of the 'chemicalFormula'
        attribute to be set

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.FbcSpeciesPlugin_setChemicalFormula(self, chemicalFormula)


    def unsetCharge(self):
        """
        unsetCharge(FbcSpeciesPlugin self) -> int


        Unsets the value of the 'charge' attribute of this FbcSpeciesPlugin.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.FbcSpeciesPlugin_unsetCharge(self)


    def unsetChemicalFormula(self):
        """
        unsetChemicalFormula(FbcSpeciesPlugin self) -> int


        Unsets the value of the 'chemicalFormula' attribute of this
        FbcSpeciesPlugin.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.FbcSpeciesPlugin_unsetChemicalFormula(self)


    def connectToParent(self, sbase):
        """
        connectToParent(FbcSpeciesPlugin self, SBase sbase)


        Internal implementation method.

        """
        return _libsbml.FbcSpeciesPlugin_connectToParent(self, sbase)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(FbcSpeciesPlugin self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.FbcSpeciesPlugin_enablePackageInternal(self, pkgURI, pkgPrefix, flag)

FbcSpeciesPlugin_swigregister = _libsbml.FbcSpeciesPlugin_swigregister
FbcSpeciesPlugin_swigregister(FbcSpeciesPlugin)

class FbcSBMLDocumentPlugin(SBMLDocumentPlugin):
    """

    [SBML 'fbc' package]  Extension of SBMLDocument for the "fbc"
    package.

    The FbcSBMLDocumentPlugin class inherits from the SBMLDocumentPlugin
    class, and codifies the extensions to the SBMLDocument class defined
    in the SBML Level 3 Flux Balance Constraints ("fbc") package.  This
    extension defines a required flag named 'required', which indicates
    whether "fbc" constructs can be used to change the core mathematical
    interpretation of the Model defined in the SBML input.  Since "fbc"
    constructs cannot, this attribute must be set to the value ''False'.'

    """

    __swig_setmethods__ = {}
    for _s in [SBMLDocumentPlugin]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FbcSBMLDocumentPlugin, name, value)
    __swig_getmethods__ = {}
    for _s in [SBMLDocumentPlugin]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, FbcSBMLDocumentPlugin, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(FbcSBMLDocumentPlugin self, string uri, string prefix, FbcPkgNamespaces fbcns) -> FbcSBMLDocumentPlugin
        __init__(FbcSBMLDocumentPlugin self, FbcSBMLDocumentPlugin orig) -> FbcSBMLDocumentPlugin


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            FbcSBMLDocumentPlugin(string uri, string prefix,
        FbcPkgNamespaces fbcns)

        Creates a new FbcSBMLDocumentPlugin object using the given parameters.

        In the XML representation of an SBML document, XML namespaces are
        used to identify the origin of each XML construct used.  XML
        namespaces are identified by their unique resource identifiers (URIs).
        The core SBML specifications stipulate the namespaces that must be
        used for core SBML constructs; for example, all XML elements that
        belong to SBML Level 3 Version 1 Core must be placed in the XML
        namespace identified by the URI
        'http://www.sbml.org/sbml/level3/version1/core'.  Individual SBML
        Level 3 packages define their own XML namespaces; for example, all
        elements belonging to the SBML Level 3 Layout Version 1 package must
        be placed in the XML namespace
        'http://www.sbml.org/sbml/level3/version1/layout/version1/'.

        The SBMLNamespaces object encapsulates SBML Level/Version/namespaces
        information.  It is used to communicate the SBML Level, Version, and
        (in Level 3) packages used in addition to SBML Level 3 Core.  A common
        approach to using libSBML's SBMLNamespaces facilities is to create an
        SBMLNamespaces object somewhere in a program once, then hand that
        object as needed to object constructors that accept SBMLNamespaces as
        arguments.

        Parameter 'uri' is the URI of the SBML Level 3 package implemented by
        this libSBML package extension.

        Parameter 'prefix' is the XML namespace prefix being used for the
        package.

        Parameter 'fbcns' is the namespaces object for the package.

        ______________________________________________________________________
        Method variant with the following signature:

            FbcSBMLDocumentPlugin(FbcSBMLDocumentPlugin orig)

        Copy constructor for FbcSBMLDocumentPlugin.

        Parameter 'orig' is the FbcSBMLDocumentPlugin instance to copy.

        """
        this = _libsbml.new_FbcSBMLDocumentPlugin(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(FbcSBMLDocumentPlugin self) -> FbcSBMLDocumentPlugin


        Creates and returns a deep copy of this FbcSBMLDocumentPlugin object.

        Returns a (deep) copy of this FbcSBMLDocumentPlugin object.

        """
        return _libsbml.FbcSBMLDocumentPlugin_clone(self)

    __swig_destroy__ = _libsbml.delete_FbcSBMLDocumentPlugin
    __del__ = lambda self: None

    def isCompFlatteningImplemented(self):
        """
        isCompFlatteningImplemented(FbcSBMLDocumentPlugin self) -> bool


        Internal implementation method.

        """
        return _libsbml.FbcSBMLDocumentPlugin_isCompFlatteningImplemented(self)


    def checkConsistency(self):
        """
        checkConsistency(FbcSBMLDocumentPlugin self) -> unsigned int


        Internal implementation method.

        """
        return _libsbml.FbcSBMLDocumentPlugin_checkConsistency(self)

FbcSBMLDocumentPlugin_swigregister = _libsbml.FbcSBMLDocumentPlugin_swigregister
FbcSBMLDocumentPlugin_swigregister(FbcSBMLDocumentPlugin)

class CobraToFbcConverter(SBMLConverter):
    """

    [SBML 'fbc' package]  COBRA to SBML Level 3 "fbc" converter.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  It is a class used in the
    implementation of extra functionality provided by libSBML.

    This converter takes a model in COBRA format and converts it to the
    "fbc" Version 2 format.

    CobraToFbcConverter is enabled by creating a ConversionProperties
    object with the option 'convert cobra' (literally that full string,
    including the spaces), and passing this properties object to
    SBMLDocument.convert().  The converter offers two options:

    * ''checkCompatibility':' whether to check the SBML Level/Version
    compatibility

    * ''removeUnits':' whether to remove unit definitions

    General information about the use of SBML converters
    ======================================================================

    The use of all the converters follows a similar approach.  First, one
    creates a ConversionProperties object and calls
    ConversionProperties.addOption() on this object with one argument: a
    text string that identifies the desired converter.  (The text string
    is specific to each converter; consult the documentation for a given
    converter to find out how it should be enabled.)

    Next, for some converters, the caller can optionally set some
    converter-specific properties using additional calls to
    ConversionProperties.addOption(). Many converters provide the ability
    to configure their behavior to some extent; this is realized through
    the use of properties that offer different options.  The default
    property values for each converter can be interrogated using the
    method SBMLConverter.getDefaultProperties() on the converter class in
    question .

    Finally, the caller should invoke the method SBMLDocument.convert()
    with the ConversionProperties object as an argument.

    Example of invoking an SBML converter
    ......................................................................

    The following code fragment illustrates an example using
    SBMLReactionConverter, which is invoked using the option string
    ''replaceReactions':'

      config = ConversionProperties()
      if config != None:
        config.addOption('replaceReactions')

    In the case of SBMLReactionConverter, there are no options to affect
    its behavior, so the next step is simply to invoke the converter on an
    SBMLDocument object.  Continuing the example code:

        # Assume that the variable 'document' has been set to an SBMLDocument object.
        status = document.convert(config)
        if status != LIBSBML_OPERATION_SUCCESS:
          # Handle error somehow.
          print('Error: conversion failed due to the following:')
          document.printErrors()

    Here is an example of using a converter that offers an option. The
    following code invokes SBMLStripPackageConverter to remove the SBML
    Level 3 Layout package from a model.  It sets the name of the package
    to be removed by adding a value for the option named ''package''
    defined by that converter:

      def strip_layout_example(document):
        config = ConversionProperties()
        if config != None:
          config.addOption('stripPackage')
          config.addOption('package', 'layout')
          status = document.convert(config)
          if status != LIBSBML_OPERATION_SUCCESS:
            # Handle error somehow.
            print('Error: unable to strip the Layout package.')
            print('LibSBML returned error: ' + OperationReturnValue_toString(status).strip())
        else:
          # Handle error somehow.
          print('Error: unable to create ConversionProperties object')

    Available SBML converters in libSBML
    ......................................................................

    LibSBML provides a number of built-in converters; by convention, their
    names end in Converter. The following are the built-in converters
    provided by libSBML 5.18.0 :

    @copydetails doc_list_of_libsbml_converters

    """

    __swig_setmethods__ = {}
    for _s in [SBMLConverter]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CobraToFbcConverter, name, value)
    __swig_getmethods__ = {}
    for _s in [SBMLConverter]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CobraToFbcConverter, name)
    __repr__ = _swig_repr

    def init():
        """
        init()


        Internal implementation method.

        """
        return _libsbml.CobraToFbcConverter_init()

    init = staticmethod(init)

    def __init__(self, *args):
        """
        __init__(CobraToFbcConverter self) -> CobraToFbcConverter
        __init__(CobraToFbcConverter self, CobraToFbcConverter orig) -> CobraToFbcConverter


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            CobraToFbcConverter(CobraToFbcConverter orig)

        Copy constructor; creates a copy of an CobraToFbcConverter object.

        Parameter 'orig' is the CobraToFbcConverter object to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            CobraToFbcConverter()

        Creates a new CobraToFbcConverter object.

        """
        this = _libsbml.new_CobraToFbcConverter(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(CobraToFbcConverter self) -> CobraToFbcConverter


        Creates and returns a deep copy of this CobraToFbcConverter object.

        Returns a (deep) copy of this CobraToFbcConverter.

        """
        return _libsbml.CobraToFbcConverter_clone(self)

    __swig_destroy__ = _libsbml.delete_CobraToFbcConverter
    __del__ = lambda self: None

    def matchesProperties(self, props):
        """
        matchesProperties(CobraToFbcConverter self, ConversionProperties props) -> bool


        Returns 'True' if this converter object's properties match the given
        properties.

        A typical use of this method involves creating a ConversionProperties
        object, setting the options desired, and then calling this method on
        an CobraToFbcConverter object to find out if the object's property
        values match the given ones.  This method is also used by
        SBMLConverterRegistry.getConverterFor() to search across all
        registered converters for one matching particular properties.

        Parameter 'props' is the properties to match.

        Returns 'True' if this converter's properties match, 'False'
        otherwise.

        """
        return _libsbml.CobraToFbcConverter_matchesProperties(self, props)


    def convert(self):
        """
        convert(CobraToFbcConverter self) -> int


        Perform the conversion.

        This method causes the converter to do the actual conversion work,
        that is, to convert the SBMLDocument object set by
        SBMLConverter.setDocument() and with the configuration options set by
        SBMLConverter.setProperties().

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        """
        return _libsbml.CobraToFbcConverter_convert(self)


    def getDefaultProperties(self):
        """
        getDefaultProperties(CobraToFbcConverter self) -> ConversionProperties


        Returns the default properties of this converter.

        A given converter exposes one or more properties that can be adjusted
        in order to influence the behavior of the converter.  This method
        returns the default property settings for this converter.  It is meant
        to be called in order to discover all the settings for the converter
        object.

        Returns the ConversionProperties object describing the default
        properties for this converter.

        """
        return _libsbml.CobraToFbcConverter_getDefaultProperties(self)


    def checkCompatibility(self):
        """
        checkCompatibility(CobraToFbcConverter self) -> bool


        Returns 'True' if the option property to check Level and Version of
        the source document (''checkCompatibility')' is 'True.'

        Returns 'True' if the option ''checkCompatibility'' has been set to
        'True,' 'False' otherwise.

        """
        return _libsbml.CobraToFbcConverter_checkCompatibility(self)

CobraToFbcConverter_swigregister = _libsbml.CobraToFbcConverter_swigregister
CobraToFbcConverter_swigregister(CobraToFbcConverter)

def CobraToFbcConverter_init():
    """
    CobraToFbcConverter_init()


    Internal implementation method.

    """
    return _libsbml.CobraToFbcConverter_init()

class FbcToCobraConverter(SBMLConverter):
    """

    [SBML 'fbc' package]  SBML Level 3 "fbc" to COBRA converter.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  It is a class used in the
    implementation of extra functionality provided by libSBML.

    This converter takes a model in "fbc" Version 2 format and converts
    it to COBRA format.

    FbcToCobraConverter is enabled by creating a ConversionProperties
    object with the option 'convert fbc to cobra' (literally that full
    string, including the spaces), and passing this properties object to
    SBMLDocument.convert().  The converter offers one option:

    * ''overwriteReactionNotes':' should gene associations be written
    into the 'notes' subelement attached to Reaction objects, even if a
    Reaction already has 'notes' content?

    General information about the use of SBML converters
    ======================================================================

    The use of all the converters follows a similar approach.  First, one
    creates a ConversionProperties object and calls
    ConversionProperties.addOption() on this object with one argument: a
    text string that identifies the desired converter.  (The text string
    is specific to each converter; consult the documentation for a given
    converter to find out how it should be enabled.)

    Next, for some converters, the caller can optionally set some
    converter-specific properties using additional calls to
    ConversionProperties.addOption(). Many converters provide the ability
    to configure their behavior to some extent; this is realized through
    the use of properties that offer different options.  The default
    property values for each converter can be interrogated using the
    method SBMLConverter.getDefaultProperties() on the converter class in
    question .

    Finally, the caller should invoke the method SBMLDocument.convert()
    with the ConversionProperties object as an argument.

    Example of invoking an SBML converter
    ......................................................................

    The following code fragment illustrates an example using
    SBMLReactionConverter, which is invoked using the option string
    ''replaceReactions':'

      config = ConversionProperties()
      if config != None:
        config.addOption('replaceReactions')

    In the case of SBMLReactionConverter, there are no options to affect
    its behavior, so the next step is simply to invoke the converter on an
    SBMLDocument object.  Continuing the example code:

        # Assume that the variable 'document' has been set to an SBMLDocument object.
        status = document.convert(config)
        if status != LIBSBML_OPERATION_SUCCESS:
          # Handle error somehow.
          print('Error: conversion failed due to the following:')
          document.printErrors()

    Here is an example of using a converter that offers an option. The
    following code invokes SBMLStripPackageConverter to remove the SBML
    Level 3 Layout package from a model.  It sets the name of the package
    to be removed by adding a value for the option named ''package''
    defined by that converter:

      def strip_layout_example(document):
        config = ConversionProperties()
        if config != None:
          config.addOption('stripPackage')
          config.addOption('package', 'layout')
          status = document.convert(config)
          if status != LIBSBML_OPERATION_SUCCESS:
            # Handle error somehow.
            print('Error: unable to strip the Layout package.')
            print('LibSBML returned error: ' + OperationReturnValue_toString(status).strip())
        else:
          # Handle error somehow.
          print('Error: unable to create ConversionProperties object')

    Available SBML converters in libSBML
    ......................................................................

    LibSBML provides a number of built-in converters; by convention, their
    names end in Converter. The following are the built-in converters
    provided by libSBML 5.18.0 :

    @copydetails doc_list_of_libsbml_converters

    """

    __swig_setmethods__ = {}
    for _s in [SBMLConverter]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FbcToCobraConverter, name, value)
    __swig_getmethods__ = {}
    for _s in [SBMLConverter]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, FbcToCobraConverter, name)
    __repr__ = _swig_repr

    def init():
        """
        init()


        Internal implementation method.

        """
        return _libsbml.FbcToCobraConverter_init()

    init = staticmethod(init)

    def __init__(self, *args):
        """
        __init__(FbcToCobraConverter self) -> FbcToCobraConverter
        __init__(FbcToCobraConverter self, FbcToCobraConverter orig) -> FbcToCobraConverter


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            FbcToCobraConverter()

        Creates a new FbcToCobraConverter object.

        ______________________________________________________________________
        Method variant with the following signature:

            FbcToCobraConverter(FbcToCobraConverter orig)

        Copy constructor; creates a copy of an FbcToCobraConverter object.

        Parameter 'orig' is the FbcToCobraConverter object to copy.

        """
        this = _libsbml.new_FbcToCobraConverter(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(FbcToCobraConverter self) -> FbcToCobraConverter


        Creates and returns a deep copy of this FbcToCobraConverter object.

        Returns a (deep) copy of this FbcToCobraConverter.

        """
        return _libsbml.FbcToCobraConverter_clone(self)

    __swig_destroy__ = _libsbml.delete_FbcToCobraConverter
    __del__ = lambda self: None

    def matchesProperties(self, props):
        """
        matchesProperties(FbcToCobraConverter self, ConversionProperties props) -> bool


        Returns 'True' if this converter object's properties match the given
        properties.

        A typical use of this method involves creating a ConversionProperties
        object, setting the options desired, and then calling this method on
        an FbcToCobraConverter object to find out if the object's property
        values match the given ones.  This method is also used by
        SBMLConverterRegistry.getConverterFor() to search across all
        registered converters for one matching particular properties.

        Parameter 'props' is the properties to match.

        Returns 'True' if this converter's properties match, 'False'
        otherwise.

        """
        return _libsbml.FbcToCobraConverter_matchesProperties(self, props)


    def convert(self):
        """
        convert(FbcToCobraConverter self) -> int


        Perform the conversion.

        This method causes the converter to do the actual conversion work,
        that is, to convert the SBMLDocument object set by
        SBMLConverter.setDocument() and with the configuration options set by
        SBMLConverter.setProperties().

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        """
        return _libsbml.FbcToCobraConverter_convert(self)


    def getDefaultProperties(self):
        """
        getDefaultProperties(FbcToCobraConverter self) -> ConversionProperties


        Returns the default properties of this converter.

        A given converter exposes one or more properties that can be adjusted
        in order to influence the behavior of the converter.  This method
        returns the default property settings for this converter.  It is meant
        to be called in order to discover all the settings for the converter
        object.

        Returns the ConversionProperties object describing the default
        properties for this converter.

        """
        return _libsbml.FbcToCobraConverter_getDefaultProperties(self)

FbcToCobraConverter_swigregister = _libsbml.FbcToCobraConverter_swigregister
FbcToCobraConverter_swigregister(FbcToCobraConverter)

def FbcToCobraConverter_init():
    """
    FbcToCobraConverter_init()


    Internal implementation method.

    """
    return _libsbml.FbcToCobraConverter_init()

class FbcV1ToV2Converter(SBMLConverter):
    """

    [SBML 'fbc' package]  Convert "fbc" Version 1 models to Version 2

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  It is a class used in the
    implementation of extra functionality provided by libSBML.

    This converter takes a model in "fbc" Version 1 format and converts
    it to "fbc" Version 2 format.

    FbcV1ToV2Converter is enabled by creating a ConversionProperties
    object with the option 'convert fbc v1 to fbc v2' (literally that full
    string, including the spaces), and passing this properties object to
    SBMLDocument.convert().  The converter accepts one option:

    * ''strict':' Should the model created be a strict one (i.e.,
    should all non-specified bounds be filled)?  (Default value of
    'True.)'

    General information about the use of SBML converters
    ======================================================================

    The use of all the converters follows a similar approach.  First, one
    creates a ConversionProperties object and calls
    ConversionProperties.addOption() on this object with one argument: a
    text string that identifies the desired converter.  (The text string
    is specific to each converter; consult the documentation for a given
    converter to find out how it should be enabled.)

    Next, for some converters, the caller can optionally set some
    converter-specific properties using additional calls to
    ConversionProperties.addOption(). Many converters provide the ability
    to configure their behavior to some extent; this is realized through
    the use of properties that offer different options.  The default
    property values for each converter can be interrogated using the
    method SBMLConverter.getDefaultProperties() on the converter class in
    question .

    Finally, the caller should invoke the method SBMLDocument.convert()
    with the ConversionProperties object as an argument.

    Example of invoking an SBML converter
    ......................................................................

    The following code fragment illustrates an example using
    SBMLReactionConverter, which is invoked using the option string
    ''replaceReactions':'

      config = ConversionProperties()
      if config != None:
        config.addOption('replaceReactions')

    In the case of SBMLReactionConverter, there are no options to affect
    its behavior, so the next step is simply to invoke the converter on an
    SBMLDocument object.  Continuing the example code:

        # Assume that the variable 'document' has been set to an SBMLDocument object.
        status = document.convert(config)
        if status != LIBSBML_OPERATION_SUCCESS:
          # Handle error somehow.
          print('Error: conversion failed due to the following:')
          document.printErrors()

    Here is an example of using a converter that offers an option. The
    following code invokes SBMLStripPackageConverter to remove the SBML
    Level 3 Layout package from a model.  It sets the name of the package
    to be removed by adding a value for the option named ''package''
    defined by that converter:

      def strip_layout_example(document):
        config = ConversionProperties()
        if config != None:
          config.addOption('stripPackage')
          config.addOption('package', 'layout')
          status = document.convert(config)
          if status != LIBSBML_OPERATION_SUCCESS:
            # Handle error somehow.
            print('Error: unable to strip the Layout package.')
            print('LibSBML returned error: ' + OperationReturnValue_toString(status).strip())
        else:
          # Handle error somehow.
          print('Error: unable to create ConversionProperties object')

    Available SBML converters in libSBML
    ......................................................................

    LibSBML provides a number of built-in converters; by convention, their
    names end in Converter. The following are the built-in converters
    provided by libSBML 5.18.0 :

    @copydetails doc_list_of_libsbml_converters

    """

    __swig_setmethods__ = {}
    for _s in [SBMLConverter]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FbcV1ToV2Converter, name, value)
    __swig_getmethods__ = {}
    for _s in [SBMLConverter]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, FbcV1ToV2Converter, name)
    __repr__ = _swig_repr

    def init():
        """
        init()


        Internal implementation method.

        """
        return _libsbml.FbcV1ToV2Converter_init()

    init = staticmethod(init)

    def __init__(self, *args):
        """
        __init__(FbcV1ToV2Converter self) -> FbcV1ToV2Converter
        __init__(FbcV1ToV2Converter self, FbcV1ToV2Converter orig) -> FbcV1ToV2Converter


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            FbcV1ToV2Converter()

        Creates a new FbcV1ToV2Converter object.

        ______________________________________________________________________
        Method variant with the following signature:

            FbcV1ToV2Converter(FbcV1ToV2Converter orig)

        Copy constructor; creates a copy of an FbcV1ToV2Converter object.

        Parameter 'orig' is the FbcV1ToV2Converter object to copy.

        """
        this = _libsbml.new_FbcV1ToV2Converter(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(FbcV1ToV2Converter self) -> FbcV1ToV2Converter


        Creates and returns a deep copy of this FbcV1ToV2Converter.

        Returns a (deep) copy of this FbcV1ToV2Converter.

        """
        return _libsbml.FbcV1ToV2Converter_clone(self)

    __swig_destroy__ = _libsbml.delete_FbcV1ToV2Converter
    __del__ = lambda self: None

    def matchesProperties(self, props):
        """
        matchesProperties(FbcV1ToV2Converter self, ConversionProperties props) -> bool


        Returns 'True' if this converter object's properties match the given
        properties.

        A typical use of this method involves creating a ConversionProperties
        object, setting the options desired, and then calling this method on
        an FbcV1ToV2Converter object to find out if the object's property
        values match the given ones.  This method is also used by
        SBMLConverterRegistry.getConverterFor() to search across all
        registered converters for one matching particular properties.

        Parameter 'props' is the properties to match.

        Returns 'True' if this converter's properties match, 'False'
        otherwise.

        """
        return _libsbml.FbcV1ToV2Converter_matchesProperties(self, props)


    def convert(self):
        """
        convert(FbcV1ToV2Converter self) -> int


        Perform the conversion.

        This method causes the converter to do the actual conversion work,
        that is, to convert the SBMLDocument object set by
        SBMLConverter.setDocument() and with the configuration options set by
        SBMLConverter.setProperties().

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        """
        return _libsbml.FbcV1ToV2Converter_convert(self)


    def getStrict(self):
        """
        getStrict(FbcV1ToV2Converter self) -> bool


        Returns a boolean, indicating whether the converter should create  a
        'strict' model, i.e.: a model with all default bounds specified.

        """
        return _libsbml.FbcV1ToV2Converter_getStrict(self)


    def getDefaultProperties(self):
        """
        getDefaultProperties(FbcV1ToV2Converter self) -> ConversionProperties


        Returns the default properties of this converter.

        A given converter exposes one or more properties that can be adjusted
        in order to influence the behavior of the converter.  This method
        returns the default property settings for this converter.  It is meant
        to be called in order to discover all the settings for the converter
        object.

        Returns the ConversionProperties object describing the default
        properties for this converter.

        """
        return _libsbml.FbcV1ToV2Converter_getDefaultProperties(self)

FbcV1ToV2Converter_swigregister = _libsbml.FbcV1ToV2Converter_swigregister
FbcV1ToV2Converter_swigregister(FbcV1ToV2Converter)

def FbcV1ToV2Converter_init():
    """
    FbcV1ToV2Converter_init()


    Internal implementation method.

    """
    return _libsbml.FbcV1ToV2Converter_init()

class FbcV2ToV1Converter(SBMLConverter):
    """

    [SBML 'fbc' package]  Convert "fbc" Version 2 models to Version 1

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  It is a class used in the
    implementation of extra functionality provided by libSBML.

    This converter takes a model in "fbc" Version 2 format and converts
    it to "fbc" Version 1 format.

    FbcV2ToV1Converter is enabled by creating a ConversionProperties
    object with the option 'convert fbc v2 to fbc v1' (literally that full
    string, including the spaces), and passing this properties object to
    SBMLDocument.convert().  The converter offers no options.  Information
    present in v2 that cannot be encoded in  v1 is lost.

    General information about the use of SBML converters
    ======================================================================

    The use of all the converters follows a similar approach.  First, one
    creates a ConversionProperties object and calls
    ConversionProperties.addOption() on this object with one argument: a
    text string that identifies the desired converter.  (The text string
    is specific to each converter; consult the documentation for a given
    converter to find out how it should be enabled.)

    Next, for some converters, the caller can optionally set some
    converter-specific properties using additional calls to
    ConversionProperties.addOption(). Many converters provide the ability
    to configure their behavior to some extent; this is realized through
    the use of properties that offer different options.  The default
    property values for each converter can be interrogated using the
    method SBMLConverter.getDefaultProperties() on the converter class in
    question .

    Finally, the caller should invoke the method SBMLDocument.convert()
    with the ConversionProperties object as an argument.

    Example of invoking an SBML converter
    ......................................................................

    The following code fragment illustrates an example using
    SBMLReactionConverter, which is invoked using the option string
    ''replaceReactions':'

      config = ConversionProperties()
      if config != None:
        config.addOption('replaceReactions')

    In the case of SBMLReactionConverter, there are no options to affect
    its behavior, so the next step is simply to invoke the converter on an
    SBMLDocument object.  Continuing the example code:

        # Assume that the variable 'document' has been set to an SBMLDocument object.
        status = document.convert(config)
        if status != LIBSBML_OPERATION_SUCCESS:
          # Handle error somehow.
          print('Error: conversion failed due to the following:')
          document.printErrors()

    Here is an example of using a converter that offers an option. The
    following code invokes SBMLStripPackageConverter to remove the SBML
    Level 3 Layout package from a model.  It sets the name of the package
    to be removed by adding a value for the option named ''package''
    defined by that converter:

      def strip_layout_example(document):
        config = ConversionProperties()
        if config != None:
          config.addOption('stripPackage')
          config.addOption('package', 'layout')
          status = document.convert(config)
          if status != LIBSBML_OPERATION_SUCCESS:
            # Handle error somehow.
            print('Error: unable to strip the Layout package.')
            print('LibSBML returned error: ' + OperationReturnValue_toString(status).strip())
        else:
          # Handle error somehow.
          print('Error: unable to create ConversionProperties object')

    Available SBML converters in libSBML
    ......................................................................

    LibSBML provides a number of built-in converters; by convention, their
    names end in Converter. The following are the built-in converters
    provided by libSBML 5.18.0 :

    @copydetails doc_list_of_libsbml_converters

    """

    __swig_setmethods__ = {}
    for _s in [SBMLConverter]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FbcV2ToV1Converter, name, value)
    __swig_getmethods__ = {}
    for _s in [SBMLConverter]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, FbcV2ToV1Converter, name)
    __repr__ = _swig_repr

    def init():
        """
        init()


        Internal implementation method.

        """
        return _libsbml.FbcV2ToV1Converter_init()

    init = staticmethod(init)

    def __init__(self, *args):
        """
        __init__(FbcV2ToV1Converter self) -> FbcV2ToV1Converter
        __init__(FbcV2ToV1Converter self, FbcV2ToV1Converter orig) -> FbcV2ToV1Converter


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            FbcV2ToV1Converter(FbcV2ToV1Converter orig)

        Copy constructor; creates a copy of an FbcV2ToV1Converter object.

        Parameter 'orig' is the FbcV2ToV1Converter object to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            FbcV2ToV1Converter()

        Creates a new FbcV2ToV1Converter object.

        """
        this = _libsbml.new_FbcV2ToV1Converter(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(FbcV2ToV1Converter self) -> FbcV2ToV1Converter


        Creates and returns a deep copy of this FbcV2ToV1Converter object.

        Returns a (deep) copy of this FbcV2ToV1Converter.

        """
        return _libsbml.FbcV2ToV1Converter_clone(self)

    __swig_destroy__ = _libsbml.delete_FbcV2ToV1Converter
    __del__ = lambda self: None

    def matchesProperties(self, props):
        """
        matchesProperties(FbcV2ToV1Converter self, ConversionProperties props) -> bool


        Returns 'True' if this converter object's properties match the given
        properties.

        A typical use of this method involves creating a ConversionProperties
        object, setting the options desired, and then calling this method on
        an FbcV2ToV1Converter object to find out if the object's property
        values match the given ones.  This method is also used by
        SBMLConverterRegistry.getConverterFor() to search across all
        registered converters for one matching particular properties.

        Parameter 'props' is the properties to match.

        Returns 'True' if this converter's properties match, 'False'
        otherwise.

        """
        return _libsbml.FbcV2ToV1Converter_matchesProperties(self, props)


    def convert(self):
        """
        convert(FbcV2ToV1Converter self) -> int


        Perform the conversion.

        This method causes the converter to do the actual conversion work,
        that is, to convert the SBMLDocument object set by setDocument() and
        with the configuration options set by setProperties().

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        """
        return _libsbml.FbcV2ToV1Converter_convert(self)


    def getDefaultProperties(self):
        """
        getDefaultProperties(FbcV2ToV1Converter self) -> ConversionProperties


        Returns the default properties of this converter.

        A given converter exposes one or more properties that can be adjusted
        in order to influence the behavior of the converter.  This method
        returns the default property settings for this converter.  It is meant
        to be called in order to discover all the settings for the converter
        object.

        Returns the ConversionProperties object describing the default
        properties for this converter.

        """
        return _libsbml.FbcV2ToV1Converter_getDefaultProperties(self)

FbcV2ToV1Converter_swigregister = _libsbml.FbcV2ToV1Converter_swigregister
FbcV2ToV1Converter_swigregister(FbcV2ToV1Converter)

def FbcV2ToV1Converter_init():
    """
    FbcV2ToV1Converter_init()


    Internal implementation method.

    """
    return _libsbml.FbcV2ToV1Converter_init()

GENE_ASSOCIATION = _libsbml.GENE_ASSOCIATION
AND_ASSOCIATION = _libsbml.AND_ASSOCIATION
OR_ASSOCIATION = _libsbml.OR_ASSOCIATION
UNKNOWN_ASSOCIATION = _libsbml.UNKNOWN_ASSOCIATION
class Association(SBase):
    """

    [SBML 'fbc' package]  Annotation helper class for "fbc" Version 1.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    The Association class is a helper class for creating annotations to
    store gene association information in Version 1 of the SBML Level 3
    Flux Balance Constraints ("fbc") package.  In "fbc" Version 2, the
    equivalent capability is handled by the FbcAssociation class and this
    class (Association) is not used.

    See also FbcAssociation, ListOfFbcAssociations.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Association, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Association, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(Association self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> Association
        __init__(Association self, unsigned int level, unsigned int version) -> Association
        __init__(Association self, unsigned int level) -> Association
        __init__(Association self) -> Association
        __init__(Association self, XMLNode node, FbcPkgNamespaces fbcns) -> Association
        __init__(Association self, FbcPkgNamespaces fbcns) -> Association
        __init__(Association self, Association source) -> Association


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            Association(XMLNode node, FbcPkgNamespaces fbcns)

        Creates a new Association with the given FbcPkgNamespaces object, and
        constructed to mimic the XMLNode: a '<gene>' node  argument will
        result in a   GENE_ASSOCIATION node; an <and> node argument will
        result in a AND_ASSOCIATION node; an <or> node argument will result in
        a OR_ASSOCIATION node.  Any other node will result in a
        UNKNOWN_ASSOCIATION node. 'And' and 'or' nodes will have Association
        children that again  parallel the children of the given XMLNode.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'fbcns' is the FbcPkgNamespaces object. Parameter 'node' is
        the XMLNode to copy.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        ______________________________________________________________________
        Method variant with the following signature:

            Association(Association source)

        Copy constructor.

        Parameter 'source' is the instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            Association(long level      = FbcExtension.getDefaultLevel(),
        long version    = FbcExtension.getDefaultVersion(), long pkgVersion =
        FbcExtension.getDefaultPackageVersion())

        Creates a new Association objet with the given SBML Level, Version,
        and "fbc" package version.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            Association(FbcPkgNamespaces fbcns)

        Creates a new Association with the given FbcPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'fbcns' is the FbcPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_Association(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_Association
    __del__ = lambda self: None

    def isFbcAnd(self):
        """
        isFbcAnd(Association self) -> bool


        Predicate returning 'True' if this abstract Association is of type
        FbcAnd

        Returns 'True' if this abstract Association is of type FbcAnd, 'False'
        otherwise

        """
        return _libsbml.Association_isFbcAnd(self)


    def isFbcOr(self):
        """
        isFbcOr(Association self) -> bool


        Predicate returning 'True' if this abstract Association is of type
        FbcOr

        Returns 'True' if this abstract Association is of type FbcOr, 'False'
        otherwise

        """
        return _libsbml.Association_isFbcOr(self)


    def isGeneProductRef(self):
        """
        isGeneProductRef(Association self) -> bool


        Predicate returning 'True' if this abstract Association is of type
        GeneProductRef

        Returns 'True' if this abstract Association is of type GeneProductRef,
        'False' otherwise

        """
        return _libsbml.Association_isGeneProductRef(self)


    def getType(self):
        """
        getType(Association self) -> AssociationTypeCode_t


        Returns the string of the 'type' attribute of this Association object.

        Returns the string of the 'type' attribute of this Association object.

        """
        return _libsbml.Association_getType(self)


    def isSetType(self):
        """
        isSetType(Association self) -> bool


        Predicate returning 'True' if this Association's 'type' attribute is
        set.

        Returns 'True' if this Association object's 'type' attribute has been
        set, otherwise 'False' is returned.

        """
        return _libsbml.Association_isSetType(self)


    def setType(self, type):
        """
        setType(Association self, AssociationTypeCode_t const type) -> int


        Sets the SIdRef string of the 'type' attribute of this Association
        object.

        Parameter 'type' is a SIdRef string to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Association_setType(self, type)


    def unsetType(self):
        """
        unsetType(Association self) -> int


        Unsets the value of the 'id' attribute of this Association object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Association_unsetType(self)


    def getReference(self):
        """
        getReference(Association self) -> string


        Returns the string of the 'reference' attribute of this Association
        object.

        Returns the string of the 'reference' attribute of this Association
        object.

        """
        return _libsbml.Association_getReference(self)


    def isSetReference(self):
        """
        isSetReference(Association self) -> bool


        Predicate returning 'True' if this Association's 'reference' attribute
        has been set.

        Returns 'True' if this Association object's 'reference' attribute has
        been set, otherwise 'False' is returned.

        """
        return _libsbml.Association_isSetReference(self)


    def setReference(self, reference):
        """
        setReference(Association self, string reference) -> int


        Sets the SIdRef string of the 'reference' attribute of this
        Association object.

        Parameter 'reference' is a SIdRef string to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Association_setReference(self, reference)


    def unsetReference(self):
        """
        unsetReference(Association self) -> int


        Unsets the value of the 'id' attribute of this Association object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Association_unsetReference(self)


    def addGene(self, id):
        """
        addGene(Association self, string id) -> int


        Adds a gene with the given 'id' to the association.

        Parameter 'id' is the gene name.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Association_addGene(self, id)


    def getNumAssociations(self):
        """
        getNumAssociations(Association self) -> unsigned int


        Returns the number of child Associations of this Association object.

        Returns the number of associations.

        """
        return _libsbml.Association_getNumAssociations(self)


    def addAssociation(self, association):
        """
        addAssociation(Association self, Association association) -> int


        Adds a child Association to this Association object.

        Parameter 'association' is the Association object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Association_addAssociation(self, association)


    def removeAssociation(self, index):
        """
        removeAssociation(Association self, int index) -> int


        Removes the child Associations with the given 'index' from this
        Association object.

        Parameter 'index' is the index number of the item to remove.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Association_removeAssociation(self, index)


    def clearAssociations(self):
        """
        clearAssociations(Association self) -> int


        Removes all children of this Association object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Association_clearAssociations(self)


    def createAnd(self):
        """
        createAnd(Association self) -> Association


        Creates a new Association of type 'and'.

        This method does not actually add the created Association as a child
        of this Association object or do anything else with it -- the
        returning pointer is now owned by the caller.

        Returns a new 'and' type association.

        """
        return _libsbml.Association_createAnd(self)


    def createOr(self):
        """
        createOr(Association self) -> Association


        Creates a new Association of type 'or'.

        This method does not actually add the created Association as a child
        of this Association object or do anything else with it -- the
        returning pointer is now owned by the caller.

        Returns a new 'or' type association.

        """
        return _libsbml.Association_createOr(self)


    def createGene(self, *args):
        """
        createGene(Association self, string reference) -> Association
        createGene(Association self) -> Association


        Creates a new Association of type 'and' with a given gene reference.

        This method does not actually add the created Association as a child
        of this Association object or do anything else with it -- the
        returning pointer is now owned by the caller.

        Parameter 'reference' is the gene reference, as a string.

        Returns a new Association object.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        return _libsbml.Association_createGene(self, *args)


    def toXML(self):
        """
        toXML(Association self) -> XMLNode


        Creates an XMLNode object from this Association object.

        """
        return _libsbml.Association_toXML(self)


    def getElementName(self):
        """
        getElementName(Association self) -> string


        Returns the XML element name of this SBML object.

        Returns the name of this element, as a text string.

        """
        return _libsbml.Association_getElementName(self)


    def clone(self):
        """
        clone(Association self) -> Association


        Creates and returns a deep copy of this Association object.

        Returns a (deep) copy of this Association object.

        """
        return _libsbml.Association_clone(self)


    def getTypeCode(self):
        """
        getTypeCode(Association self) -> int


        Returns the libSBML type code of this object instance.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_FBC_ASSOCIATION.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.Association_getTypeCode(self)


    def parseInfixAssociation(association):
        """
        parseInfixAssociation(string association) -> Association


        Parses a gene association in infix format and returns a corresponding
        Association object.

        This parses a string that has a list of gene names and conjunctions or
        disjunctions.  For example:

          (b2422) and (b2425) and (b2423) and (b2424) or (b2422) and (b2423) and (b2424) and (b2413) and (b3917)

        Parameter 'association' is the string to parse.

        Returns the parsed association, or 'None' in case of an error.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        See also toInfix().

        """
        return _libsbml.Association_parseInfixAssociation(association)

    parseInfixAssociation = staticmethod(parseInfixAssociation)

    def toInfix(self):
        """
        toInfix(Association self) -> string


        Converts this Association object into an infix string representation.
        The format is the same as is found in parseInfixAssociation().

        Returns the association as infix string.

        See also parseInfixAssociation().

        """
        return _libsbml.Association_toInfix(self)

Association_swigregister = _libsbml.Association_swigregister
Association_swigregister(Association)

def Association_parseInfixAssociation(association):
    """
    Association_parseInfixAssociation(string association) -> Association


    Parses a gene association in infix format and returns a corresponding
    Association object.

    This parses a string that has a list of gene names and conjunctions or
    disjunctions.  For example:

      (b2422) and (b2425) and (b2423) and (b2424) or (b2422) and (b2423) and (b2424) and (b2413) and (b3917)

    Parameter 'association' is the string to parse.

    Returns the parsed association, or 'None' in case of an error.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    See also toInfix().

    """
    return _libsbml.Association_parseInfixAssociation(association)

FLUXBOUND_OPERATION_LESS_EQUAL = _libsbml.FLUXBOUND_OPERATION_LESS_EQUAL
FLUXBOUND_OPERATION_GREATER_EQUAL = _libsbml.FLUXBOUND_OPERATION_GREATER_EQUAL
FLUXBOUND_OPERATION_LESS = _libsbml.FLUXBOUND_OPERATION_LESS
FLUXBOUND_OPERATION_GREATER = _libsbml.FLUXBOUND_OPERATION_GREATER
FLUXBOUND_OPERATION_EQUAL = _libsbml.FLUXBOUND_OPERATION_EQUAL
FLUXBOUND_OPERATION_UNKNOWN = _libsbml.FLUXBOUND_OPERATION_UNKNOWN
class FluxBound(SBase):
    """

    [SBML 'fbc' package]  Max or min value for a reaction flux.

    The FluxBound class of objects is used in Version 1 of the SBML Level
    3 Flux Balance Constraints ("fbc") package to express a single
    (in)equality that provides the maximum or minimum value that a
    reaction flux can obtain at steady state.  (This same information is
    encoded differently in Version 2 of "fbc"; see the 'upperFluxBound'
    and 'lowerFluxBound' attributes on FbcReactionPlugin.)

    Attributes on FluxBound
    ======================================================================

    In addition to the common optional attributes 'id' and 'name',
    FluxBound takes three required attributes: 'reaction', 'operation' and
    'value'. These three attributes define the meaning of the FluxBound,
    and are interpreted using the following expression: <center> reaction
    operator   value </center>

    The 'reaction' attribute takes a value of SIdRef.  The value must be
    the identifier of a Reaction object defined within the enclosing
    model.

    The 'operation' attribute takes a value from a set of constants whose
    names begin with FLUXBOUND_ representing different mathematical
    inequalities. Possible values for 'operation' include 'greaterEqual',
    'equal', and others.

    The 'value' attribute takes a numerical value of type double, and
    represents the value of the flux bound.  The permitted values include
    positive infinity ('INF') and negative infinity ('-INF').

    The following is an example of a set of flux bounds encoded in this
    form; it also demonstrates the use of ListOfFluxBounds.

      <fbc:listOfFluxBounds>
          <fbc:fluxBound fbc:id='R1b' fbc:reaction='R1' fbc:operation='greaterEqual' fbc:value='1.2'/>
          <fbc:fluxBound fbc:id='R2b' fbc:reaction='R2' fbc:operation='lessEqual' fbc:value='-1.2'/>
          <fbc:fluxBound fbc:id='R3b' fbc:reaction='R3' fbc:operation='greaterEqual' fbc:value='-INF'/>
          <fbc:fluxBound fbc:id='R4b' fbc:reaction='R4' fbc:operation='lessEqual' fbc:value='INF'/>
          <fbc:fluxBound fbc:id='R5b' fbc:reaction='R5' fbc:operation='equal' fbc:value='1'/>
      </fbc:listOfFluxBounds>

    Note: This class is only defined for Version 1 of the "fbc" package
    specification.  It was replaced in Version 2 by a Parameter referenced
    by the 'upperFluxBound' or 'lowerFluxBound' attributes on an
    FbcReactionPlugin.  FluxBound is therefore not used for Version 2
    "fbc" models.

    See also ListOfFluxBounds.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FluxBound, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, FluxBound, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(FluxBound self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> FluxBound
        __init__(FluxBound self, unsigned int level, unsigned int version) -> FluxBound
        __init__(FluxBound self, unsigned int level) -> FluxBound
        __init__(FluxBound self) -> FluxBound
        __init__(FluxBound self, FbcPkgNamespaces fbcns) -> FluxBound
        __init__(FluxBound self, FluxBound source) -> FluxBound


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            FluxBound(long level      = FbcExtension.getDefaultLevel(),
        long version    = FbcExtension.getDefaultVersion(), long pkgVersion =
        FbcExtension.getDefaultPackageVersion())

        Creates a new FbcAssociation with the given SBML Level, Version, and
        "fbc"package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        FluxObjective.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this FluxObjective.

        Parameter 'pkgVersion' is a long integer, the SBML Fbc Version to
        assign to this FluxObjective.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            FluxBound(FluxBound source)

        Copy constructor.

        Parameter 'source' is the instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            FluxBound(FbcPkgNamespaces fbcns)

        Creates a new FluxBound with the given FbcPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'fbcns' is the FbcPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_FluxBound(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_FluxBound
    __del__ = lambda self: None

    def getId(self):
        """
        getId(FluxBound self) -> string


        Returns the value of the 'id' attribute of this FluxBound.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is now recommended to use the
        getIdAttribute() function instead.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns the id of this FluxBound.

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.FluxBound_getId(self)


    def isSetId(self):
        """
        isSetId(FluxBound self) -> bool


        Predicate returning 'True' if this FluxBound's 'id' attribute is set.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns 'True' if the 'id' attribute of this SBML object is set,
        'False' otherwise.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is recommended that callers use
        isSetIdAttribute() instead.

        See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(),
        isSetIdAttribute().

        """
        return _libsbml.FluxBound_isSetId(self)


    def setId(self, sid):
        """
        setId(FluxBound self, string sid) -> int


        Sets the value of the 'id' attribute of this FluxBound.

        The string 'sid' is copied.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Parameter 'sid' is the string to use as the identifier of this object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.FluxBound_setId(self, sid)


    def unsetId(self):
        """
        unsetId(FluxBound self) -> int


        Unsets the value of the 'id' attribute of this FluxBound object.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.FluxBound_unsetId(self)


    def getName(self):
        """
        getName(FluxBound self) -> string


        Returns the value of the 'name' attribute of this FluxBound object.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns the name of this SBML object, or the empty string if not set
        or unsettable.

        See also getIdAttribute(), isSetName(), setName(), unsetName().

        """
        return _libsbml.FluxBound_getName(self)


    def isSetName(self):
        """
        isSetName(FluxBound self) -> bool


        Predicate returning 'True' if this FluxBound's 'name' attribute is
        set.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns 'True' if the 'name' attribute of this SBML object is set,
        'False' otherwise.

        See also getName(), setName(), unsetName().

        """
        return _libsbml.FluxBound_isSetName(self)


    def setName(self, name):
        """
        setName(FluxBound self, string name) -> int


        Sets the value of the 'name' attribute of this FluxBound.

        The string in 'name' is copied.

        Parameter 'name' is the new name for the SBML object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.FluxBound_setName(self, name)


    def unsetName(self):
        """
        unsetName(FluxBound self) -> int


        Unsets the value of the 'name' attribute of this FluxBound object.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getName(), setName(), isSetName().

        """
        return _libsbml.FluxBound_unsetName(self)


    def getReaction(self):
        """
        getReaction(FluxBound self) -> string


        Returns the value of the 'reaction' attribute of this FluxBound
        object.

        Returns the value of the 'reaction' attribute of this FluxBound
        object.

        """
        return _libsbml.FluxBound_getReaction(self)


    def isSetReaction(self):
        """
        isSetReaction(FluxBound self) -> bool


        Predicate returning 'True' if this FluxBound's 'reaction' attribute is
        set.

        Returns 'True' if this FluxBound object's 'reaction' attribute has
        been set, otherwise 'False' is returned.

        """
        return _libsbml.FluxBound_isSetReaction(self)


    def setReaction(self, reaction):
        """
        setReaction(FluxBound self, string reaction) -> int


        Sets the value of the 'reaction' attribute of this FluxBound object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.FluxBound_setReaction(self, reaction)


    def unsetReaction(self):
        """
        unsetReaction(FluxBound self) -> int


        Unsets the value of the 'reaction' attribute of this FluxBound object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.FluxBound_unsetReaction(self)


    def getOperation(self):
        """
        getOperation(FluxBound self) -> string


        Returns the value of the 'operation' attribute of this FluxBound
        object.

        Returns the value of the 'operation' attribute of this FluxBound
        object.

        """
        return _libsbml.FluxBound_getOperation(self)


    def getFluxBoundOperation(self):
        """
        getFluxBoundOperation(FluxBound self) -> FluxBoundOperation_t


        Returns the value of the 'operation' attribute of this FluxBound
        object.

        Returns the value of the 'operation' attribute of this FluxBound
        object.

        """
        return _libsbml.FluxBound_getFluxBoundOperation(self)


    def isSetOperation(self):
        """
        isSetOperation(FluxBound self) -> bool


        Predicate returning 'True' if this FluxBound's 'operation' attribute
        is set.

        Returns 'True' if this FluxBound object's 'operation' attribute has
        been set, otherwise 'False' is returned.

        """
        return _libsbml.FluxBound_isSetOperation(self)


    def setOperation(self, *args):
        """
        setOperation(FluxBound self, string operation) -> int
        setOperation(FluxBound self, FluxBoundOperation_t operation) -> int


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            setOperation(string operation)

        Sets the value of the 'operation' attribute of this FluxBound object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        ______________________________________________________________________
        Method variant with the following signature:

            setOperation(FluxBoundOperation_t operation)

        Sets the value of the 'operation' attribute of this FluxBound object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.FluxBound_setOperation(self, *args)


    def unsetOperation(self):
        """
        unsetOperation(FluxBound self) -> int


        Unsets the value of the 'operation' attribute of this FluxBound
        object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.FluxBound_unsetOperation(self)


    def getValue(self):
        """
        getValue(FluxBound self) -> double


        Returns the value of the 'value' attribute of this FluxBound object.

        Returns the value of the 'value' attribute of this FluxBound object.

        """
        return _libsbml.FluxBound_getValue(self)


    def isSetValue(self):
        """
        isSetValue(FluxBound self) -> bool


        Predicate returning 'True' if this FluxBound's 'value' attribute is
        set.

        Returns 'True' if this FluxBound object's 'value' attribute has been
        set, otherwise 'False' is returned.

        """
        return _libsbml.FluxBound_isSetValue(self)


    def setValue(self, value):
        """
        setValue(FluxBound self, double const value) -> int


        Sets the value of the 'value' attribute of this FluxBound object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.FluxBound_setValue(self, value)


    def unsetValue(self):
        """
        unsetValue(FluxBound self) -> int


        Unsets the value of the 'value' attribute of this FluxBound object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.FluxBound_unsetValue(self)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(FluxBound self, string oldid, string newid)


        Replaces all uses of a given 'SIdRef' type attribute value with
        another value.

        In SBML, object identifiers are of a data type called SId. In SBML
        Level 3, an explicit data type called SIdRef was introduced for
        attribute values that refer to SId values; in previous Levels of SBML,
        this data type did not exist and attributes were simply described to
        as 'referring to an identifier', but the effective data type was the
        same as SIdRef in Level 3.  These and other methods of libSBML refer
        to the type SIdRef for all Levels of SBML, even if the corresponding
        SBML specification did not explicitly name the data type.

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas in MathML content, comparing the referenced
        identifiers to the value of 'oldid'.  If any matches are found, the
        matching values are replaced with 'newid'.  The method does not
        descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.FluxBound_renameSIdRefs(self, oldid, newid)


    def getElementName(self):
        """
        getElementName(FluxBound self) -> string


        Returns the XML element name of this object.

        For FluxBound, the XML element name is always ''fluxBound'.'

        Returns the name of this element, i.e. ''fluxBound'.'

        """
        return _libsbml.FluxBound_getElementName(self)


    def clone(self):
        """
        clone(FluxBound self) -> FluxBound


        Creates and returns a deep copy of this FluxBound object.

        Returns a (deep) copy of this FluxBound object.

        """
        return _libsbml.FluxBound_clone(self)


    def getTypeCode(self):
        """
        getTypeCode(FluxBound self) -> int


        Returns the libSBML type code of this object instance.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_FBC_FLUXBOUND.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.FluxBound_getTypeCode(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(FluxBound self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.FluxBound_enablePackageInternal(self, pkgURI, pkgPrefix, flag)

FluxBound_swigregister = _libsbml.FluxBound_swigregister
FluxBound_swigregister(FluxBound)

class ListOfFluxBounds(ListOf):
    """

    [SBML 'fbc' package]  A list of FluxBound objects.

    The ListOfFluxBounds is a container for the FluxBound elements of a
    Model. It is only defined for Version 1 of the "fbc" specification,
    and was replaced in Version 2 by Parameter elements referenced by the
    'upperFluxBound' or 'lowerFluxBound' attributes on an
    FbcReactionPlugin.  FluxBound and ListOfFluxBounds are not used for
    Version 2 "fbc" models.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    See also FluxBound.

    Note: This class and FluxBound are only defined for Version 1 of the
    "fbc" package specification.  These classes are not used in Version
    2 of "fbc".

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfFluxBounds, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfFluxBounds, name)
    __repr__ = _swig_repr

    def clone(self):
        """
        clone(ListOfFluxBounds self) -> ListOfFluxBounds


        Creates and returns a deep copy of this ListOfFluxBounds.

        Returns a (deep) copy of this ListOfFluxBounds.

        """
        return _libsbml.ListOfFluxBounds_clone(self)


    def __init__(self, *args):
        """
        __init__(ListOfFluxBounds self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ListOfFluxBounds
        __init__(ListOfFluxBounds self, unsigned int level, unsigned int version) -> ListOfFluxBounds
        __init__(ListOfFluxBounds self, unsigned int level) -> ListOfFluxBounds
        __init__(ListOfFluxBounds self) -> ListOfFluxBounds
        __init__(ListOfFluxBounds self, FbcPkgNamespaces fbcns) -> ListOfFluxBounds


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfFluxBounds(long level      =
        FbcExtension.getDefaultLevel(), long version    =
        FbcExtension.getDefaultVersion(), long pkgVersion =
        FbcExtension.getDefaultPackageVersion())

        Creates a new ListOfFluxBounds with the given level, version, and
        package version.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfFluxBounds(FbcPkgNamespaces fbcns)

        Creates a new ListOfFluxBounds with the given FbcPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'fbcns' is the FbcPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_ListOfFluxBounds(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def get(self, *args):
        """
        get(ListOfFluxBounds self, unsigned int n) -> FluxBound
        get(ListOfFluxBounds self, unsigned int n) -> FluxBound
        get(ListOfFluxBounds self, string sid) -> FluxBound
        get(ListOfFluxBounds self, string sid) -> FluxBound


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a FluxBound from the ListOfFluxBounds.

        Parameter 'n' is the index number of the FluxBound to get.

        Returns the nth FluxBound in this ListOfFluxBounds. If the index 'n'
        is invalid, 'None' is returned.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a FluxBound from the ListOfFluxBounds based on its identifier.

        Parameter 'sid' is a string representing the identifier of the
        FluxBound to get.

        Returns FluxBound in this ListOfFluxBounds with the given 'sid' or
        'None' if no such FluxBound exists.

        See also get(), size().

        """
        return _libsbml.ListOfFluxBounds_get(self, *args)


    def remove(self, *args):
        """
        remove(ListOfFluxBounds self, unsigned int n) -> FluxBound
        remove(ListOfFluxBounds self, string sid) -> FluxBound


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth item from this ListOfFluxBounds items and returns a
        pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the item to remove.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes item in this ListOfFluxBounds 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 'sid', then
        'None' is returned.

        Parameter 'sid' is the identifier of the item to remove.

        Returns the item removed.  As mentioned above, the caller owns the
        returned item.

        """
        return _libsbml.ListOfFluxBounds_remove(self, *args)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfFluxBounds self) -> int


        Returns the libSBML type code for the SBML objects contained in this
        ListOf object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for objects contained in this list:
        SBML_FBC_FLUXBOUND (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfFluxBounds_getItemTypeCode(self)


    def getElementName(self):
        """
        getElementName(ListOfFluxBounds self) -> string


        Returns the XML element name of this object.

        For ListOfFluxBounds, the XML element name is always
        ''listOfFluxBounds'.'

        Returns the name of this element, i.e. ''listOfFluxBounds'.'

        """
        return _libsbml.ListOfFluxBounds_getElementName(self)

    __swig_destroy__ = _libsbml.delete_ListOfFluxBounds
    __del__ = lambda self: None
ListOfFluxBounds_swigregister = _libsbml.ListOfFluxBounds_swigregister
ListOfFluxBounds_swigregister(ListOfFluxBounds)

class FluxObjective(SBase):
    """

    [SBML 'fbc' package]  An objective function for a flux.

    An integral component in a complete description of a steady-state
    model is the so-called objective function, which generally consists of
    a linear combination of model variables (fluxes) and a sense
    (direction). In the SBML Level 3 Flux Balance Constraints ("fbc")
    package, this concept is succinctly captured in the Objective class.
    An Objective object includes a list of flux objectives, each in the
    form of a FluxObjective object. The FluxObjective class is a
    relatively simple container for a model variable weighted by a signed
    linear coefficient.  In addition to the common SBML object attributes
    of 'id' and 'name' (both of which are optional), it adds two required
    attributes: 'reaction' and 'coefficient'.

    The 'reaction' attribute must have a value of type SIdRef, and its
    value is restricted to the identifier of a Reaction object in the
    model.  The 'reaction' attribute identifiers the reaction to which the
    FluxObjective applies.  The 'coefficient' attribute must have a value
    of type double, and refers to the coefficient that this FluxObjective
    takes in the enclosing Objective.  Its unit of measurement is
    dimensionless.  The meaning of these two attributes together is given
    by the formula coefficient &times; reaction-flux.  Since reactions in
    SBML Level 3 are in units of extent, the units of a flux objective are
    thus extent per time.

    The following example * illustrates the use of these attributes in an
    example of a * ListOfObjectives:

      <fbc:listOfObjectives fbc:activeObjective='obj1'>
       <fbc:objective fbc:id='obj1' fbc:type='maximize'>
        <fbc:listOfFluxObjectives>
         <fbc:fluxObjective fbc:reaction='R1' fbc:coefficient='1'/>
         <fbc:fluxObjective fbc:reaction='R2' fbc:coefficient='2'/>
        </fbc:listOfFluxObjectives>
       </fbc:objective>
      </fbc:listOfObjectives>

    See also Objective, ListOfObjectives, ListOfFluxObjectives.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FluxObjective, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, FluxObjective, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(FluxObjective self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> FluxObjective
        __init__(FluxObjective self, unsigned int level, unsigned int version) -> FluxObjective
        __init__(FluxObjective self, unsigned int level) -> FluxObjective
        __init__(FluxObjective self) -> FluxObjective
        __init__(FluxObjective self, FbcPkgNamespaces fbcns) -> FluxObjective
        __init__(FluxObjective self, FluxObjective orig) -> FluxObjective


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            FluxObjective(long level      =
        FbcExtension.getDefaultLevel(), long version    =
        FbcExtension.getDefaultVersion(), long pkgVersion =
        FbcExtension.getDefaultPackageVersion())

        Creates a new FluxObjective with the given SBML Level, Version, and
        "fbc"package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        FluxObjective.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this FluxObjective.

        Parameter 'pkgVersion' is a long integer, the SBML Fbc Version to
        assign to this FluxObjective.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            FluxObjective(FluxObjective orig)

        Copy constructor for FluxObjective.

        Parameter 'orig' is the FluxObjective instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            FluxObjective(FbcPkgNamespaces fbcns)

        Creates a new FluxObjective with the given FbcPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'fbcns' is the FbcPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_FluxObjective(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(FluxObjective self) -> FluxObjective


        Creates and returns a deep copy of this FluxObjective object.

        Returns a (deep) copy of this FluxObjective object.

        """
        return _libsbml.FluxObjective_clone(self)

    __swig_destroy__ = _libsbml.delete_FluxObjective
    __del__ = lambda self: None

    def getId(self):
        """
        getId(FluxObjective self) -> string


        Returns the value of the 'id' attribute of this FluxObjective.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is now recommended to use the
        getIdAttribute() function instead.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns the id of this FluxObjective.

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.FluxObjective_getId(self)


    def getName(self):
        """
        getName(FluxObjective self) -> string


        Returns the value of the 'name' attribute of this FluxObjective
        object.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns the name of this SBML object, or the empty string if not set
        or unsettable.

        See also getIdAttribute(), isSetName(), setName(), unsetName().

        """
        return _libsbml.FluxObjective_getName(self)


    def getReaction(self):
        """
        getReaction(FluxObjective self) -> string


        Returns the value of the 'reaction' attribute of this FluxObjective.

        Returns the value of the 'reaction' attribute of this FluxObjective as
        a string.

        """
        return _libsbml.FluxObjective_getReaction(self)


    def getCoefficient(self):
        """
        getCoefficient(FluxObjective self) -> double


        Returns the value of the 'coefficient' attribute of this
        FluxObjective.

        Returns the value of the 'coefficient' attribute of this FluxObjective
        as a double.

        """
        return _libsbml.FluxObjective_getCoefficient(self)


    def isSetId(self):
        """
        isSetId(FluxObjective self) -> bool


        Predicate returning 'True' if this FluxObjective's 'id' attribute is
        set.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns 'True' if the 'id' attribute of this SBML object is set,
        'False' otherwise.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is recommended that callers use
        isSetIdAttribute() instead.

        See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(),
        isSetIdAttribute().

        """
        return _libsbml.FluxObjective_isSetId(self)


    def isSetName(self):
        """
        isSetName(FluxObjective self) -> bool


        Predicate returning 'True' if this FluxObjective's 'name' attribute is
        set.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns 'True' if the 'name' attribute of this SBML object is set,
        'False' otherwise.

        See also getName(), setName(), unsetName().

        """
        return _libsbml.FluxObjective_isSetName(self)


    def isSetReaction(self):
        """
        isSetReaction(FluxObjective self) -> bool


        Predicate returning 'True' if this FluxObjective's 'reaction'
        attribute is set.

        Returns 'True' if this FluxObjective's 'reaction' attribute has been
        set, otherwise 'False' is returned.

        """
        return _libsbml.FluxObjective_isSetReaction(self)


    def isSetCoefficient(self):
        """
        isSetCoefficient(FluxObjective self) -> bool


        Predicate returning 'True' if this FluxObjective's 'coefficient'
        attribute is set.

        Returns 'True' if this FluxObjective's 'coefficient' attribute has
        been set, otherwise 'False' is returned.

        """
        return _libsbml.FluxObjective_isSetCoefficient(self)


    def setId(self, sid):
        """
        setId(FluxObjective self, string sid) -> int


        Sets the value of the 'id' attribute of this FluxObjective.

        The string 'sid' is copied.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Parameter 'sid' is the string to use as the identifier of this object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.FluxObjective_setId(self, sid)


    def setName(self, name):
        """
        setName(FluxObjective self, string name) -> int


        Sets the value of the 'name' attribute of this FluxObjective.

        The string in 'name' is copied.

        Parameter 'name' is the new name for the SBML object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.FluxObjective_setName(self, name)


    def setReaction(self, reaction):
        """
        setReaction(FluxObjective self, string reaction) -> int


        Sets the value of the 'reaction' attribute of this FluxObjective.

        Parameter 'reaction' is the value of the 'reaction' attribute to be
        set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.FluxObjective_setReaction(self, reaction)


    def setCoefficient(self, coefficient):
        """
        setCoefficient(FluxObjective self, double coefficient) -> int


        Sets the value of the 'coefficient' attribute of this FluxObjective.

        Parameter 'coefficient' is the value of the 'coefficient' attribute to
        be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.FluxObjective_setCoefficient(self, coefficient)


    def unsetId(self):
        """
        unsetId(FluxObjective self) -> int


        Unsets the value of the 'id' attribute of this FluxObjective.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.FluxObjective_unsetId(self)


    def unsetName(self):
        """
        unsetName(FluxObjective self) -> int


        Unsets the value of the 'name' attribute of this FluxObjective.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getName(), setName(), isSetName().

        """
        return _libsbml.FluxObjective_unsetName(self)


    def unsetReaction(self):
        """
        unsetReaction(FluxObjective self) -> int


        Unsets the value of the 'reaction' attribute of this FluxObjective.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.FluxObjective_unsetReaction(self)


    def unsetCoefficient(self):
        """
        unsetCoefficient(FluxObjective self) -> int


        Unsets the value of the 'coefficient' attribute of this FluxObjective.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.FluxObjective_unsetCoefficient(self)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(FluxObjective self, string oldid, string newid)


        Replaces all uses of a given 'SIdRef' type attribute value with
        another value.

        In SBML, object identifiers are of a data type called SId. In SBML
        Level 3, an explicit data type called SIdRef was introduced for
        attribute values that refer to SId values; in previous Levels of SBML,
        this data type did not exist and attributes were simply described to
        as 'referring to an identifier', but the effective data type was the
        same as SIdRef in Level 3.  These and other methods of libSBML refer
        to the type SIdRef for all Levels of SBML, even if the corresponding
        SBML specification did not explicitly name the data type.

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas in MathML content, comparing the referenced
        identifiers to the value of 'oldid'.  If any matches are found, the
        matching values are replaced with 'newid'.  The method does not
        descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.FluxObjective_renameSIdRefs(self, oldid, newid)


    def getElementName(self):
        """
        getElementName(FluxObjective self) -> string


        Returns the XML element name of this object.

        For FluxObjective, the XML element name is always ''fluxObjective'.'

        Returns the name of this element, i.e. ''fluxObjective'.'

        """
        return _libsbml.FluxObjective_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(FluxObjective self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_FBC_FLUXOBJECTIVE
        (default).

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.FluxObjective_getTypeCode(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(FluxObjective self) -> bool


        Predicate returning 'True' if all the required attributes for this
        FluxObjective object have been set.

        Note: The required attributes for a FluxObjective object are:

        * 'reaction'

        * 'coefficient'

        Returns a boolean value indicating whether all the required attributes
        for this object have been defined.

        """
        return _libsbml.FluxObjective_hasRequiredAttributes(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(FluxObjective self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.FluxObjective_enablePackageInternal(self, pkgURI, pkgPrefix, flag)

FluxObjective_swigregister = _libsbml.FluxObjective_swigregister
FluxObjective_swigregister(FluxObjective)

class ListOfFluxObjectives(ListOf):
    """

    [SBML 'fbc' package]  A list of FluxObjective objects.

    The ListOfFluxObjectives is a container for the "fbc" Objective that
    indicate which fluxes (and what ratios for those fluxes) are to be
    used in maximizing or minimizing the Objective.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    See also Objective, FluxObjective.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfFluxObjectives, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfFluxObjectives, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ListOfFluxObjectives self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ListOfFluxObjectives
        __init__(ListOfFluxObjectives self, unsigned int level, unsigned int version) -> ListOfFluxObjectives
        __init__(ListOfFluxObjectives self, unsigned int level) -> ListOfFluxObjectives
        __init__(ListOfFluxObjectives self) -> ListOfFluxObjectives
        __init__(ListOfFluxObjectives self, FbcPkgNamespaces fbcns) -> ListOfFluxObjectives


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfFluxObjectives(long level      =
        FbcExtension.getDefaultLevel(), long version    =
        FbcExtension.getDefaultVersion(), long pkgVersion =
        FbcExtension.getDefaultPackageVersion())

        Creates a new ListOfFluxObjectives with the given level, version, and
        package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        ListOfFluxObjectives.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this ListOfFluxObjectives.

        Parameter 'pkgVersion' is a long integer, the SBML Fbc Version to
        assign to this ListOfFluxObjectives.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfFluxObjectives(FbcPkgNamespaces fbcns)

        Creates a new ListOfFluxObjectives with the given FbcPkgNamespaces
        object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'fbcns' is the FbcPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_ListOfFluxObjectives(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ListOfFluxObjectives self) -> ListOfFluxObjectives


        Creates and returns a deep copy of this ListOfFluxObjectives object.

        Returns a (deep) copy of this ListOfFluxObjectives object.

        """
        return _libsbml.ListOfFluxObjectives_clone(self)


    def get(self, *args):
        """
        get(ListOfFluxObjectives self, unsigned int n) -> FluxObjective
        get(ListOfFluxObjectives self, unsigned int n) -> FluxObjective
        get(ListOfFluxObjectives self, string sid) -> FluxObjective
        get(ListOfFluxObjectives self, string sid) -> FluxObjective


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a FluxObjective from the ListOfFluxObjectives.

        Parameter 'n' is the index number of the FluxObjective to get.

        Returns the nth FluxObjective in this ListOfFluxObjectives. If the
        index 'n' is invalid, 'None' is returned.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a FluxObjective from the ListOfFluxObjectives based on its
        identifier.

        Parameter 'sid' is a string representing the identifier of the
        FluxObjective to get.

        Returns FluxObjective in this ListOfFluxObjectives with the given id
        or 'None' if no such FluxObjective exists.

        See also get()   *, size().

        """
        return _libsbml.ListOfFluxObjectives_get(self, *args)


    def addFluxObjective(self, fo):
        """
        addFluxObjective(ListOfFluxObjectives self, FluxObjective fo) -> int


        Adds a copy the given FluxObjective to this ListOfFluxObjectives.

        Parameter 'fo' is the FluxObjective object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.ListOfFluxObjectives_addFluxObjective(self, fo)


    def getNumFluxObjectives(self):
        """
        getNumFluxObjectives(ListOfFluxObjectives self) -> unsigned int


        Get the number of FluxObjective objects in this ListOfFluxObjectives.

        Returns the number of FluxObjective objects in this
        ListOfFluxObjectives

        """
        return _libsbml.ListOfFluxObjectives_getNumFluxObjectives(self)


    def createFluxObjective(self):
        """
        createFluxObjective(ListOfFluxObjectives self) -> FluxObjective


        Creates a new FluxObjective object, adds it to the
        ListOfFluxObjectives and returns the FluxObjective object created.

        Returns a new FluxObjective object instance

        See also addFluxObjective().

        """
        return _libsbml.ListOfFluxObjectives_createFluxObjective(self)


    def remove(self, *args):
        """
        remove(ListOfFluxObjectives self, unsigned int n) -> FluxObjective
        remove(ListOfFluxObjectives self, string sid) -> FluxObjective


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth FluxObjective from this ListOfFluxObjectives and
        returns a pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the FluxObjective to remove.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes the FluxObjective from this ListOfFluxObjectives with the
        given identifier and returns a pointer to it.

        The caller owns the returned item and is responsible for deleting it.
        If none of the items in this list have the identifier 'sid', then
        'None' is returned.

        Parameter 'sid' is the identifier of the FluxObjective to remove.

        Returns the FluxObjective removed. As mentioned above, the caller owns
        the returned item.

        """
        return _libsbml.ListOfFluxObjectives_remove(self, *args)


    def getElementName(self):
        """
        getElementName(ListOfFluxObjectives self) -> string


        Returns the XML element name of this object.

        For ListOfFluxObjectives, the XML element name is always
        ''listOfFluxObjectives'.'

        Returns the name of this element, i.e. ''listOfFluxObjectives'.'

        """
        return _libsbml.ListOfFluxObjectives_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(ListOfFluxObjectives self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_LIST_OF (default).

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfFluxObjectives_getTypeCode(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfFluxObjectives self) -> int


        Returns the libSBML type code for the objects contained in this
        ListOf.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for the objects contained in this ListOf
        instance: SBML_FBC_FLUXOBJECTIVE (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfFluxObjectives_getItemTypeCode(self)

    __swig_destroy__ = _libsbml.delete_ListOfFluxObjectives
    __del__ = lambda self: None
ListOfFluxObjectives_swigregister = _libsbml.ListOfFluxObjectives_swigregister
ListOfFluxObjectives_swigregister(ListOfFluxObjectives)

class GeneAssociation(SBase):
    """

    [SBML 'fbc' package]  Annotation helper class for "fbc" Version 1.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    GeneAssociation is a helper class for creating annotations to store
    gene association information.  It is part of a proposed approach to
    annotating models in Version 1 of the SBML Level 3 Flux Balance
    Constraints ("fbc") package.  It is not part of the official "fbc"
    specification, and not defined in Version 2 of the "fbc" package
    specification.  In "fbc" Version 2, the equivalent capability is
    handled by the GeneProductAssociation class and this class
    (GeneAssociation) is not used.

    See also ListOfGeneAssociations, GeneProductAssociation,
    ListOfGeneProducts.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GeneAssociation, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, GeneAssociation, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(GeneAssociation self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> GeneAssociation
        __init__(GeneAssociation self, unsigned int level, unsigned int version) -> GeneAssociation
        __init__(GeneAssociation self, unsigned int level) -> GeneAssociation
        __init__(GeneAssociation self) -> GeneAssociation
        __init__(GeneAssociation self, XMLNode node, FbcPkgNamespaces fbcns) -> GeneAssociation
        __init__(GeneAssociation self, FbcPkgNamespaces fbcns) -> GeneAssociation
        __init__(GeneAssociation self, GeneAssociation source) -> GeneAssociation


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            GeneAssociation(XMLNode node, FbcPkgNamespaces fbcns)

        Creates a new GeneAssociation with the given 'node' and
        FbcPkgNamespaces 'fbcns'.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'node' is the XMLNode to copy. Parameter 'fbcns' is the
        FbcPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        ______________________________________________________________________
        Method variant with the following signature:

            GeneAssociation(long level      =
        FbcExtension.getDefaultLevel(), long version    =
        FbcExtension.getDefaultVersion(), long pkgVersion =
        FbcExtension.getDefaultPackageVersion())

        Creates a new GeneAssociation with the given 'level', 'version', and
        'pkgVersion'.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            GeneAssociation(GeneAssociation source)

        Copy constructor.

        Parameter 'source' is the instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            GeneAssociation(FbcPkgNamespaces fbcns)

        Creates a new GeneAssociation with the given FbcPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'fbcns' is the FbcPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_GeneAssociation(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_GeneAssociation
    __del__ = lambda self: None

    def getId(self):
        """
        getId(GeneAssociation self) -> string


        Returns the value of the 'id' attribute of this GeneAssociation.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is now recommended to use the
        getIdAttribute() function instead.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns the id of this GeneAssociation.

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.GeneAssociation_getId(self)


    def isSetId(self):
        """
        isSetId(GeneAssociation self) -> bool


        Predicate returning 'True' if this GeneAssociation's 'id' attribute is
        set.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns 'True' if the 'id' attribute of this SBML object is set,
        'False' otherwise.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is recommended that callers use
        isSetIdAttribute() instead.

        See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(),
        isSetIdAttribute().

        """
        return _libsbml.GeneAssociation_isSetId(self)


    def setId(self, sid):
        """
        setId(GeneAssociation self, string sid) -> int


        Sets the value of the 'id' attribute of this GeneAssociation.

        The string 'sid' is copied.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Parameter 'sid' is the string to use as the identifier of this object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.GeneAssociation_setId(self, sid)


    def unsetId(self):
        """
        unsetId(GeneAssociation self) -> int


        Unsets the value of the 'id' attribute of this GeneAssociation.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.GeneAssociation_unsetId(self)


    def getReaction(self):
        """
        getReaction(GeneAssociation self) -> string


        Returns the string of the 'reaction' attribute of this
        GeneAssociation.

        Returns the string of the 'reaction' attribute of this
        GeneAssociation.

        """
        return _libsbml.GeneAssociation_getReaction(self)


    def isSetReaction(self):
        """
        isSetReaction(GeneAssociation self) -> bool


        Predicate returning 'True' if this GeneAssociation's 'reaction'
        attribute is set.

        Returns 'True' if this GeneAssociation's 'reaction' attribute has been
        set,  otherwise 'False' is returned.

        """
        return _libsbml.GeneAssociation_isSetReaction(self)


    def setReaction(self, reaction):
        """
        setReaction(GeneAssociation self, string reaction) -> int


        Sets the SIdRef string of the 'reaction' attribute of this
        GeneAssociation.

        Parameter 'reaction' is a SIdRef string to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.GeneAssociation_setReaction(self, reaction)


    def unsetReaction(self):
        """
        unsetReaction(GeneAssociation self) -> int


        Unsets the value of the 'id' attribute of this GeneAssociation.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.GeneAssociation_unsetReaction(self)


    def createAssociation(self):
        """
        createAssociation(GeneAssociation self) -> Association


        Creates a new association, sets it to this element and returns it.

        """
        return _libsbml.GeneAssociation_createAssociation(self)


    def getAssociation(self, *args):
        """
        getAssociation(GeneAssociation self) -> Association
        getAssociation(GeneAssociation self) -> Association


        Returns Association object of this GeneAssociation.

        Returns Association object of this GeneAssociation.

        """
        return _libsbml.GeneAssociation_getAssociation(self, *args)


    def isSetAssociation(self):
        """
        isSetAssociation(GeneAssociation self) -> bool


        Predicate returning 'True' if this GeneAssociation's 'association'
        element is set.

        Returns 'True' if this GeneAssociation's 'association' element has
        been set,  otherwise 'False' is returned.

        """
        return _libsbml.GeneAssociation_isSetAssociation(self)


    def setAssociation(self, association):
        """
        setAssociation(GeneAssociation self, Association association) -> int


        Sets the Association object of this GeneAssociation.

        Parameter 'association' is a Association object to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.GeneAssociation_setAssociation(self, association)


    def unsetAssociation(self):
        """
        unsetAssociation(GeneAssociation self) -> int


        Unsets the Association object of this GeneAssociation.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.GeneAssociation_unsetAssociation(self)


    def getElementName(self):
        """
        getElementName(GeneAssociation self) -> string


        Returns the XML element name of this object.

        For GeneAssociation, the XML element name is always
        ''geneAssociation'.'

        Returns the name of this element, i.e. ''geneAssociation'.'

        """
        return _libsbml.GeneAssociation_getElementName(self)


    def clone(self):
        """
        clone(GeneAssociation self) -> GeneAssociation


        Creates and returns a deep copy of this GeneAssociation.

        Returns a (deep) copy of this GeneAssociation.

        """
        return _libsbml.GeneAssociation_clone(self)


    def getTypeCode(self):
        """
        getTypeCode(GeneAssociation self) -> int


        Returns the libSBML type code of this object instance.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_FBC_GENEASSOCIATION

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.GeneAssociation_getTypeCode(self)


    def toXML(self):
        """
        toXML(GeneAssociation self) -> XMLNode


        Creates an XMLNode object from this.

        """
        return _libsbml.GeneAssociation_toXML(self)

GeneAssociation_swigregister = _libsbml.GeneAssociation_swigregister
GeneAssociation_swigregister(GeneAssociation)

class ListOfGeneAssociations(ListOf):
    """

    [SBML 'fbc' package]  A list of GeneAssociation objects.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    The ListOfGeneAssociations is a container for GeneAssociation
    elements; both constructs are part of a proposed approach to
    annotating models in Version 1 of the SBML Level 3 Flux Balance
    Constraints ("fbc") package.  They are not part of the official
    "fbc" specification, and are not defined in Version 2 of the "fbc"
    package specification.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    See also GeneAssociation.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfGeneAssociations, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfGeneAssociations, name)
    __repr__ = _swig_repr

    def clone(self):
        """
        clone(ListOfGeneAssociations self) -> ListOfGeneAssociations


        Creates and returns a deep copy of this ListOfGeneAssociations.

        Returns a (deep) copy of this ListOfGeneAssociations.

        """
        return _libsbml.ListOfGeneAssociations_clone(self)


    def __init__(self, *args):
        """
        __init__(ListOfGeneAssociations self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ListOfGeneAssociations
        __init__(ListOfGeneAssociations self, unsigned int level, unsigned int version) -> ListOfGeneAssociations
        __init__(ListOfGeneAssociations self, unsigned int level) -> ListOfGeneAssociations
        __init__(ListOfGeneAssociations self) -> ListOfGeneAssociations
        __init__(ListOfGeneAssociations self, FbcPkgNamespaces fbcns) -> ListOfGeneAssociations


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfGeneAssociations(long level      =
        FbcExtension.getDefaultLevel(), long version    =
        FbcExtension.getDefaultVersion(), long pkgVersion =
        FbcExtension.getDefaultPackageVersion())

        Creates a new ListOfGeneAssociations with the given level, version,
        and package version.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfGeneAssociations(FbcPkgNamespaces fbcns)

        Creates a new ListOfGeneAssociations with the given FbcPkgNamespaces
        object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'fbcns' is the FbcPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_ListOfGeneAssociations(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def get(self, *args):
        """
        get(ListOfGeneAssociations self, unsigned int n) -> GeneAssociation
        get(ListOfGeneAssociations self, unsigned int n) -> GeneAssociation
        get(ListOfGeneAssociations self, string sid) -> GeneAssociation
        get(ListOfGeneAssociations self, string sid) -> GeneAssociation


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a GeneAssociation from the ListOfGeneAssociations.

        Parameter 'n' is the index number of the GeneAssociation to get.

        Returns the nth GeneAssociation in this ListOfGeneAssociations. If the
        index 'n' is invalid, 'None' is returned.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a GeneAssociation from the ListOfGeneAssociations based on its
        identifier.

        Parameter 'sid' is a string representing the identifier  of the
        GeneAssociation to get.

        Returns GeneAssociation in this ListOfGeneAssociations with the given
        'sid' or 'None' if no such GeneAssociation exists.

        See also get(), size().

        """
        return _libsbml.ListOfGeneAssociations_get(self, *args)


    def remove(self, *args):
        """
        remove(ListOfGeneAssociations self, unsigned int n) -> GeneAssociation
        remove(ListOfGeneAssociations self, string sid) -> GeneAssociation


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth item from this ListOfGeneAssociations items and
        returns a pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the item to remove. Returns the item
        removed.  As mentioned above, the caller owns the returned item.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes item in this ListOfGeneAssociations 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 'sid', then
        'None' is returned.

        Parameter 'sid' is the identifier of the item to remove.

        Returns the item removed.  As mentioned above, the caller owns the
        returned item.

        """
        return _libsbml.ListOfGeneAssociations_remove(self, *args)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfGeneAssociations self) -> int


        Returns the libSBML type code for the SBML objects contained in this
        ListOf object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for objects contained in this list:
        SBML_FBC_GENEASSOCIATION (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfGeneAssociations_getItemTypeCode(self)


    def getElementName(self):
        """
        getElementName(ListOfGeneAssociations self) -> string


        Returns the XML element name of this object.

        For ListOfGeneAssociations, the XML element name is always
        ''listOfGeneAssociations'.'

        Returns the name of this element, i.e. ''listOfGeneAssociations'.'

        """
        return _libsbml.ListOfGeneAssociations_getElementName(self)

    __swig_destroy__ = _libsbml.delete_ListOfGeneAssociations
    __del__ = lambda self: None
ListOfGeneAssociations_swigregister = _libsbml.ListOfGeneAssociations_swigregister
ListOfGeneAssociations_swigregister(ListOfGeneAssociations)

OBJECTIVE_TYPE_MAXIMIZE = _libsbml.OBJECTIVE_TYPE_MAXIMIZE
OBJECTIVE_TYPE_MINIMIZE = _libsbml.OBJECTIVE_TYPE_MINIMIZE
OBJECTIVE_TYPE_UNKNOWN = _libsbml.OBJECTIVE_TYPE_UNKNOWN
class Objective(SBase):
    """

    [SBML 'fbc' package]  An objective function.

    An integral component in a complete description of a steady-state
    model is the so-called objective function, which generally consists of
    a linear combination of model variables (fluxes) and a sense
    (direction). In the SBML Level 3 Flux Balance Constraints ("fbc")
    package, this concept is succinctly captured in the Objective class.

    The Objective class is derived from the normal SBML SBase class and
    inherits the 'metaid' and 'sboTerm' attributes, as well as the
    subcomponents for Annotation and Notes.  To these, the Objective class
    adds an optional attribute named 'type'.  The type attribute can take
    one of two literal values: ''maximize'' or ''minimize'.'  The values
    represent the sense of the optimality constraint for the FBC model.

    The "fbc" package allows for the definition of multiple model
    objectives, with one being designated as active.  The active objective
    is indicated using the attribute 'activeObjective' on the
    ListOfObjectives object. Here is an example of the XML encoding of a
    model with a list of objective functions:

      <fbc:listOfObjectives fbc:activeObjective='obj1'>
       <fbc:objective fbc:id='obj1' fbc:type='maximize'>
        <fbc:listOfFluxObjectives>
         <fbc:fluxObjective fbc:reaction='R101' fbc:coefficient='1'/>
        </fbc:listOfFluxObjectives>
       </fbc:objective>
       <fbc:objective fbc:id='obj2' fbc:type='minimize'>
        <fbc:listOfFluxObjectives>
         <fbc:fluxObjective fbc:reaction='R102' fbc:coefficient='-2.5'/>
         <fbc:fluxObjective fbc:reaction='R103' fbc:coefficient='1'/>
        </fbc:listOfFluxObjectives>
       </fbc:objective>
      </fbc:listOfObjectives>

    See also FluxObjective, ListOfObjectives.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Objective, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Objective, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(Objective self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> Objective
        __init__(Objective self, unsigned int level, unsigned int version) -> Objective
        __init__(Objective self, unsigned int level) -> Objective
        __init__(Objective self) -> Objective
        __init__(Objective self, FbcPkgNamespaces fbcns) -> Objective
        __init__(Objective self, Objective orig) -> Objective


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            Objective(Objective orig)

        Copy constructor for Objective.

        Parameter 'orig' is the Objective instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            Objective(long level      = FbcExtension.getDefaultLevel(),
        long version    = FbcExtension.getDefaultVersion(), long pkgVersion =
        FbcExtension.getDefaultPackageVersion())

        Creates a new Objective with the given SBML Level, Version, and
        "fbc"package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        Objective.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this Objective.

        Parameter 'pkgVersion' is a long integer, the SBML Fbc Version to
        assign to this Objective.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            Objective(FbcPkgNamespaces fbcns)

        Creates a new Objective with the given FbcPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'fbcns' is the FbcPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_Objective(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(Objective self) -> Objective


        Creates and returns a deep copy of this Objective object.

        Returns a (deep) copy of this Objective object.

        """
        return _libsbml.Objective_clone(self)

    __swig_destroy__ = _libsbml.delete_Objective
    __del__ = lambda self: None

    def getId(self):
        """
        getId(Objective self) -> string


        Returns the value of the 'id' attribute of this Objective.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is now recommended to use the
        getIdAttribute() function instead.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns the id of this Objective.

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.Objective_getId(self)


    def getName(self):
        """
        getName(Objective self) -> string


        Returns the value of the 'name' attribute of this Objective object.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns the name of this SBML object, or the empty string if not set
        or unsettable.

        See also getIdAttribute(), isSetName(), setName(), unsetName().

        """
        return _libsbml.Objective_getName(self)


    def getObjectiveType(self):
        """
        getObjectiveType(Objective self) -> ObjectiveType_t


        Returns the enumeration value of the 'type' attribute of this
        Objective.

        Returns the enumeration value of the 'type' attribute of this
        Objective.

        """
        return _libsbml.Objective_getObjectiveType(self)


    def getType(self):
        """
        getType(Objective self) -> string


        Returns the string of the 'type' attribute of this Objective.

        Returns the string of the 'type' attribute of this Objective.

        """
        return _libsbml.Objective_getType(self)


    def isSetId(self):
        """
        isSetId(Objective self) -> bool


        Predicate returning 'True' if this Objective's 'id' attribute is set.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns 'True' if the 'id' attribute of this SBML object is set,
        'False' otherwise.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is recommended that callers use
        isSetIdAttribute() instead.

        See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(),
        isSetIdAttribute().

        """
        return _libsbml.Objective_isSetId(self)


    def isSetName(self):
        """
        isSetName(Objective self) -> bool


        Predicate returning 'True' if this Objective's 'name' attribute is
        set.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns 'True' if the 'name' attribute of this SBML object is set,
        'False' otherwise.

        See also getName(), setName(), unsetName().

        """
        return _libsbml.Objective_isSetName(self)


    def isSetType(self):
        """
        isSetType(Objective self) -> bool


        Predicate returning 'True' if this Objective's 'type' attribute is
        set.

        Returns 'True' if this Objective's 'type' attribute has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.Objective_isSetType(self)


    def setId(self, sid):
        """
        setId(Objective self, string sid) -> int


        Sets the value of the 'id' attribute of this Objective.

        The string 'sid' is copied.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Parameter 'sid' is the string to use as the identifier of this object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.Objective_setId(self, sid)


    def setName(self, name):
        """
        setName(Objective self, string name) -> int


        Sets the value of the 'name' attribute of this Objective.

        The string in 'name' is copied.

        Parameter 'name' is the new name for the SBML object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Objective_setName(self, name)


    def setType(self, *args):
        """
        setType(Objective self, ObjectiveType_t type) -> int
        setType(Objective self, string type) -> int


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            setType(string type)

        Sets the value of the 'type' attribute of this Objective.

        Parameter 'type' is string value of the 'type' attribute to be set.
        Valid values include:

        * 'maximize' (OBJECTIVE_TYPE_MAXIMIZE)

        * 'minimize' (OBJECTIVE_TYPE_MINIMIZE)

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        ______________________________________________________________________
        Method variant with the following signature:

            setType(ObjectiveType_t type)

        Sets the value of the 'type' attribute of this Objective.

        The 'type' must be a value from one of the constants whose names begin
        with OBJECTIVE_TYPE_.

        Parameter 'type' is string value of the 'type' attribute to be set.
        Valid values include:

        * OBJECTIVE_TYPE_MAXIMIZE

        * OBJECTIVE_TYPE_MINIMIZE

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Objective_setType(self, *args)


    def unsetId(self):
        """
        unsetId(Objective self) -> int


        Unsets the value of the 'id' attribute of this Objective.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.Objective_unsetId(self)


    def unsetName(self):
        """
        unsetName(Objective self) -> int


        Unsets the value of the 'name' attribute of this Objective.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getName(), setName(), isSetName().

        """
        return _libsbml.Objective_unsetName(self)


    def unsetType(self):
        """
        unsetType(Objective self) -> int


        Unsets the value of the 'type' attribute of this Objective.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Objective_unsetType(self)


    def getListOfFluxObjectives(self, *args):
        """
        getListOfFluxObjectives(Objective self) -> ListOfFluxObjectives
        getListOfFluxObjectives(Objective self) -> ListOfFluxObjectives


        Returns the ListOfFluxObjectives in this Objective object.

        Returns the ListOfFluxObjectives child of this Objective.

        """
        return _libsbml.Objective_getListOfFluxObjectives(self, *args)


    def getFluxObjective(self, *args):
        """
        getFluxObjective(Objective self, unsigned int n) -> FluxObjective
        getFluxObjective(Objective self, unsigned int n) -> FluxObjective
        getFluxObjective(Objective self, string sid) -> FluxObjective
        getFluxObjective(Objective self, string sid) -> FluxObjective


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getFluxObjective(long n)

        Get a FluxObjective from the ListOfFluxObjectives.

        Parameter 'n' is the index number of the FluxObjective to get.

        Returns the nth FluxObjective in the ListOfFluxObjectives within this
        Objective. If the index 'n' is invalid, 'None' is returned.

        See also getNumFluxObjectives().

        ______________________________________________________________________
        Method variant with the following signature:

            getFluxObjective(string sid)

        Get a FluxObjective from the ListOfFluxObjectives based on its
        identifier.

        Parameter 'sid' is a string representing the identifier of the
        FluxObjective to get.

        Returns the FluxObjective in the ListOfFluxObjectives with the given
        id or 'None' if no such FluxObjective exists.

        See also getFluxObjective().

        See also getNumFluxObjectives().

        """
        return _libsbml.Objective_getFluxObjective(self, *args)


    def addFluxObjective(self, fo):
        """
        addFluxObjective(Objective self, FluxObjective fo) -> int


        Adds a copy the given FluxObjective to this Objective.

        Parameter 'fo' is the FluxObjective object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Objective_addFluxObjective(self, fo)


    def getNumFluxObjectives(self):
        """
        getNumFluxObjectives(Objective self) -> unsigned int


        Get the number of FluxObjective objects in this Objective.

        Returns the number of FluxObjective objects in this Objective.

        """
        return _libsbml.Objective_getNumFluxObjectives(self)


    def createFluxObjective(self):
        """
        createFluxObjective(Objective self) -> FluxObjective


        Creates a new FluxObjective object.

        This method creates the FluxObjective object, adds it to this
        Objective object's ListOfFluxObjectives, and returns the FluxObjective
        object created.

        Returns a new FluxObjective object instance.

        See also addFluxObjective().

        """
        return _libsbml.Objective_createFluxObjective(self)


    def removeFluxObjective(self, *args):
        """
        removeFluxObjective(Objective self, unsigned int n) -> FluxObjective
        removeFluxObjective(Objective self, string sid) -> FluxObjective


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeFluxObjective(long n)

        Removes the nth FluxObjective from the ListOfFluxObjectives.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the FluxObjective to remove.

        See also getNumFluxObjectives().

        ______________________________________________________________________
        Method variant with the following signature:

            removeFluxObjective(string sid)

        Removes the FluxObjective with the given identifier from the
        ListOfFluxObjectives.

        The caller owns the returned item and is responsible for deleting it.
        If none of the items in this list have the identifier 'sid', then
        'None' is returned.

        Parameter 'sid' is the identifier of the FluxObjective to remove.

        Returns the FluxObjective removed. As mentioned above, the caller owns
        the returned item.

        """
        return _libsbml.Objective_removeFluxObjective(self, *args)


    def getElementName(self):
        """
        getElementName(Objective self) -> string


        Returns the XML element name of this object.

        For Objective, the XML element name is always ''objective'.'

        Returns the name of this element, i.e. ''objective'.'

        """
        return _libsbml.Objective_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(Objective self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_FBC_OBJECTIVE
        (default).

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.Objective_getTypeCode(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(Objective self) -> bool


        Predicate returning 'True' if all the required attributes for this
        Objective object have been set.

        Note: The required attributes for a Objective object are:

        * 'id'

        * 'type'

        Returns a boolean value indicating whether all the required attributes
        for this object have been defined.

        """
        return _libsbml.Objective_hasRequiredAttributes(self)


    def hasRequiredElements(self):
        """
        hasRequiredElements(Objective self) -> bool


        Predicate returning 'True' if all the required elements for this
        Objective object have been set.

        Note: The required elements for a Objective object are:

        * at least one FluxObjective child of the ListOfFluxObjectives.

        Returns a boolean value indicating whether all the required elements
        for this object have been defined.

        """
        return _libsbml.Objective_hasRequiredElements(self)


    def connectToChild(self):
        """
        connectToChild(Objective self)


        Internal implementation method.

        """
        return _libsbml.Objective_connectToChild(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(Objective self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.Objective_enablePackageInternal(self, pkgURI, pkgPrefix, flag)


    def getIsSetListOfFluxObjectives(self):
        """
        getIsSetListOfFluxObjectives(Objective self) -> bool


        Internal implementation method.

        """
        return _libsbml.Objective_getIsSetListOfFluxObjectives(self)

Objective_swigregister = _libsbml.Objective_swigregister
Objective_swigregister(Objective)

class ListOfObjectives(ListOf):
    """

    [SBML 'fbc' package]  A list of Objective objects.

    The ListOfObjectives is a container for the SBML extended Model that
    lists all the possible Objective elements in the model.

    Unlike most other ListOf subclasses in SBML, SBML Level 3 Flux Balance
    Constraints Version 2 defines an additional required attribute on
    ListOfObjectives: the 'activeObjective' attribute.  This attribute is
    of type SIdRef and can only refer to the id of an existing Objective.
    This required attribute exists so that when multiple Objective's are
    included in a single model, the model will always be well described;
    i.e., there will be a single, primary objective function which defines
    a single optimum and its associated solution space.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    See also GeneProduct, FbcModelPlugin.

    WARNING:

    The required attribute 'activeObjective' on ListOfObjectives is an
    additional attribute that is not present on typical ListOf classes.
    The introduction of an attribute on ListOf is perfectly legal in SBML,
    but uncommon, and software developers may have grown accustomed to
    ListOf classes all having the same attributes and no others.  We are
    belaboring this point so that developers are more likely to notice the
    presence of an additional attribute on ListOfObjectives.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfObjectives, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfObjectives, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ListOfObjectives self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ListOfObjectives
        __init__(ListOfObjectives self, unsigned int level, unsigned int version) -> ListOfObjectives
        __init__(ListOfObjectives self, unsigned int level) -> ListOfObjectives
        __init__(ListOfObjectives self) -> ListOfObjectives
        __init__(ListOfObjectives self, FbcPkgNamespaces fbcns) -> ListOfObjectives
        __init__(ListOfObjectives self, ListOfObjectives other) -> ListOfObjectives


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfObjectives(long level      =
        FbcExtension.getDefaultLevel(), long version    =
        FbcExtension.getDefaultVersion(), long pkgVersion =
        FbcExtension.getDefaultPackageVersion())

        Creates a new ListOfObjectives with the given SBML Level, Version, and
        "fbc"package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        ListOfObjectives.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this ListOfObjectives.

        Parameter 'pkgVersion' is a long integer, the SBML Fbc Version to
        assign to this ListOfObjectives.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfObjectives(ListOfObjectives other)

        Copy Constructor.

        Parameter 'other' is the instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfObjectives(FbcPkgNamespaces fbcns)

        Creates a new ListOfObjectives with the given FbcPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'fbcns' is the FbcPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_ListOfObjectives(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ListOfObjectives self) -> ListOfObjectives


        Creates and returns a deep copy of this ListOfObjectives object.

        Returns a (deep) copy of this ListOfObjectives object.

        """
        return _libsbml.ListOfObjectives_clone(self)


    def get(self, *args):
        """
        get(ListOfObjectives self, unsigned int n) -> Objective
        get(ListOfObjectives self, unsigned int n) -> Objective
        get(ListOfObjectives self, string sid) -> Objective
        get(ListOfObjectives self, string sid) -> Objective


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get an Objective from the ListOfObjectives.

        Parameter 'n' is the index number of the Objective to get.

        Returns the nth Objective in this ListOfObjectives. If the index 'n'
        is invalid, 'None' is returned.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get an Objective from the ListOfObjectives based on its identifier.

        Parameter 'sid' is a string representing the identifier of the
        Objective to get.

        Returns Objective in this ListOfObjectives with the given id or 'None'
        if no such Objective exists.

        See also get(), size().

        """
        return _libsbml.ListOfObjectives_get(self, *args)


    def addObjective(self, o):
        """
        addObjective(ListOfObjectives self, Objective o) -> int


        Adds a copy the given Objective to this ListOfObjectives.

        Parameter 'o' is the Objective object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.ListOfObjectives_addObjective(self, o)


    def getNumObjectives(self):
        """
        getNumObjectives(ListOfObjectives self) -> unsigned int


        Get the number of Objective objects in this ListOfObjectives.

        Returns the number of Objective objects in this ListOfObjectives.

        """
        return _libsbml.ListOfObjectives_getNumObjectives(self)


    def createObjective(self):
        """
        createObjective(ListOfObjectives self) -> Objective


        Creates a new Objective object, adds it to the ListOfObjectives and
        returns the Objective object created.

        Returns a new Objective object instance.

        See also addObjective().

        """
        return _libsbml.ListOfObjectives_createObjective(self)


    def remove(self, *args):
        """
        remove(ListOfObjectives self, unsigned int n) -> Objective
        remove(ListOfObjectives self, string sid) -> Objective


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth Objective from this ListOfObjectives and returns a
        pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the Objective to remove.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes the Objective from this ListOfObjectives with the given
        identifier and returns a pointer to it.

        The caller owns the returned item and is responsible for deleting it.
        If none of the items in this list have the identifier 'sid', then
        'None' is returned.

        Parameter 'sid' is the identifier of the Objective to remove.

        Returns the Objective removed. As mentioned above, the caller owns the
        returned item.

        """
        return _libsbml.ListOfObjectives_remove(self, *args)


    def getElementName(self):
        """
        getElementName(ListOfObjectives self) -> string


        Returns the XML element name of this object.

        For ListOfObjectives, the XML element name is always
        ''listOfObjectives'.'

        Returns the name of this element, i.e. ''listOfObjectives'.'

        """
        return _libsbml.ListOfObjectives_getElementName(self)


    def isSetActiveObjective(self):
        """
        isSetActiveObjective(ListOfObjectives self) -> bool


        Predicate returning 'True' if this ListOfObjective's 'activeObjective'
        attribute is set.

        Returns 'True' if this ListOfObjective's 'activeObjective' attribute
        has been set, otherwise 'False' is returned.

        """
        return _libsbml.ListOfObjectives_isSetActiveObjective(self)


    def setActiveObjective(self, activeObjective):
        """
        setActiveObjective(ListOfObjectives self, string activeObjective) -> int


        Sets the value of the 'activeObjective' attribute of this
        ListOfObjectives.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.ListOfObjectives_setActiveObjective(self, activeObjective)


    def getActiveObjective(self):
        """
        getActiveObjective(ListOfObjectives self) -> string


        Returns the value of the 'activeObjective' attribute of this
        ListOfObjectives.

        Returns the value of the 'activeObjective' attribute of this
        ListOfObjectives.

        """
        return _libsbml.ListOfObjectives_getActiveObjective(self)


    def unsetActiveObjective(self):
        """
        unsetActiveObjective(ListOfObjectives self) -> int


        Unsets the value of the 'activeObjective' attribute of this
        ListOfObjectives.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.ListOfObjectives_unsetActiveObjective(self)


    def getTypeCode(self):
        """
        getTypeCode(ListOfObjectives self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_LIST_OF (default).

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfObjectives_getTypeCode(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfObjectives self) -> int


        Returns the libSBML type code for the objects contained in this
        ListOf.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for the objects contained in this ListOf
        instance: SBML_FBC_OBJECTIVE (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfObjectives_getItemTypeCode(self)


    def appendFrom(self, list):
        """
        appendFrom(ListOfObjectives self, ListOf list) -> int


        Adds a clone of all items in the provided ListOf to this object.

        This means that when this ListOf is destroyed, the original items will
        not be destroyed.  In addition, copy over the input ListOfObjectives'
        'activeObjective' attribute, if none is set for this element.

        Parameter 'list' is a list of items to be added.

        See also append().

        """
        return _libsbml.ListOfObjectives_appendFrom(self, list)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(ListOfObjectives self, string oldid, string newid)


        Replaces all uses of a given 'SIdRef' type attribute value with
        another value.

        In SBML, object identifiers are of a data type called SId. In SBML
        Level 3, an explicit data type called SIdRef was introduced for
        attribute values that refer to SId values; in previous Levels of SBML,
        this data type did not exist and attributes were simply described to
        as 'referring to an identifier', but the effective data type was the
        same as SIdRef in Level 3.  These and other methods of libSBML refer
        to the type SIdRef for all Levels of SBML, even if the corresponding
        SBML specification did not explicitly name the data type.

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas in MathML content, comparing the referenced
        identifiers to the value of 'oldid'.  If any matches are found, the
        matching values are replaced with 'newid'.  The method does not
        descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.ListOfObjectives_renameSIdRefs(self, oldid, newid)

    __swig_destroy__ = _libsbml.delete_ListOfObjectives
    __del__ = lambda self: None
ListOfObjectives_swigregister = _libsbml.ListOfObjectives_swigregister
ListOfObjectives_swigregister(ListOfObjectives)

FbcUnknown = _libsbml.FbcUnknown
FbcNSUndeclared = _libsbml.FbcNSUndeclared
FbcElementNotInNs = _libsbml.FbcElementNotInNs
FbcDuplicateComponentId = _libsbml.FbcDuplicateComponentId
FbcSBMLSIdSyntax = _libsbml.FbcSBMLSIdSyntax
FbcAttributeRequiredMissing = _libsbml.FbcAttributeRequiredMissing
FbcAttributeRequiredMustBeBoolean = _libsbml.FbcAttributeRequiredMustBeBoolean
FbcRequiredFalse = _libsbml.FbcRequiredFalse
FbcOnlyOneEachListOf = _libsbml.FbcOnlyOneEachListOf
FbcNoEmptyListOfs = _libsbml.FbcNoEmptyListOfs
FbcLOFluxBoundsAllowedElements = _libsbml.FbcLOFluxBoundsAllowedElements
FbcLOObjectivesAllowedElements = _libsbml.FbcLOObjectivesAllowedElements
FbcLOFluxBoundsAllowedAttributes = _libsbml.FbcLOFluxBoundsAllowedAttributes
FbcLOObjectivesAllowedAttributes = _libsbml.FbcLOObjectivesAllowedAttributes
FbcActiveObjectiveSyntax = _libsbml.FbcActiveObjectiveSyntax
FbcActiveObjectiveRefersObjective = _libsbml.FbcActiveObjectiveRefersObjective
FbcModelMustHaveStrict = _libsbml.FbcModelMustHaveStrict
FbcModelStrictMustBeBoolean = _libsbml.FbcModelStrictMustBeBoolean
FbcLOGeneProductsAllowedElements = _libsbml.FbcLOGeneProductsAllowedElements
FbcLOGeneProductsAllowedAttributes = _libsbml.FbcLOGeneProductsAllowedAttributes
FbcSpeciesAllowedL3Attributes = _libsbml.FbcSpeciesAllowedL3Attributes
FbcSpeciesChargeMustBeInteger = _libsbml.FbcSpeciesChargeMustBeInteger
FbcSpeciesFormulaMustBeString = _libsbml.FbcSpeciesFormulaMustBeString
FbcFluxBoundAllowedL3Attributes = _libsbml.FbcFluxBoundAllowedL3Attributes
FbcFluxBoundAllowedElements = _libsbml.FbcFluxBoundAllowedElements
FbcFluxBoundRequiredAttributes = _libsbml.FbcFluxBoundRequiredAttributes
FbcFluxBoundRectionMustBeSIdRef = _libsbml.FbcFluxBoundRectionMustBeSIdRef
FbcFluxBoundNameMustBeString = _libsbml.FbcFluxBoundNameMustBeString
FbcFluxBoundOperationMustBeEnum = _libsbml.FbcFluxBoundOperationMustBeEnum
FbcFluxBoundValueMustBeDouble = _libsbml.FbcFluxBoundValueMustBeDouble
FbcFluxBoundReactionMustExist = _libsbml.FbcFluxBoundReactionMustExist
FbcFluxBoundsForReactionConflict = _libsbml.FbcFluxBoundsForReactionConflict
FbcObjectiveAllowedL3Attributes = _libsbml.FbcObjectiveAllowedL3Attributes
FbcObjectiveAllowedElements = _libsbml.FbcObjectiveAllowedElements
FbcObjectiveRequiredAttributes = _libsbml.FbcObjectiveRequiredAttributes
FbcObjectiveNameMustBeString = _libsbml.FbcObjectiveNameMustBeString
FbcObjectiveTypeMustBeEnum = _libsbml.FbcObjectiveTypeMustBeEnum
FbcObjectiveOneListOfObjectives = _libsbml.FbcObjectiveOneListOfObjectives
FbcObjectiveLOFluxObjMustNotBeEmpty = _libsbml.FbcObjectiveLOFluxObjMustNotBeEmpty
FbcObjectiveLOFluxObjOnlyFluxObj = _libsbml.FbcObjectiveLOFluxObjOnlyFluxObj
FbcObjectiveLOFluxObjAllowedAttribs = _libsbml.FbcObjectiveLOFluxObjAllowedAttribs
FbcFluxObjectAllowedL3Attributes = _libsbml.FbcFluxObjectAllowedL3Attributes
FbcFluxObjectAllowedElements = _libsbml.FbcFluxObjectAllowedElements
FbcFluxObjectRequiredAttributes = _libsbml.FbcFluxObjectRequiredAttributes
FbcFluxObjectNameMustBeString = _libsbml.FbcFluxObjectNameMustBeString
FbcFluxObjectReactionMustBeSIdRef = _libsbml.FbcFluxObjectReactionMustBeSIdRef
FbcFluxObjectReactionMustExist = _libsbml.FbcFluxObjectReactionMustExist
FbcFluxObjectCoefficientMustBeDouble = _libsbml.FbcFluxObjectCoefficientMustBeDouble
FbcFluxObjectCoefficientWhenStrict = _libsbml.FbcFluxObjectCoefficientWhenStrict
FbcReactionOnlyOneGeneProdAss = _libsbml.FbcReactionOnlyOneGeneProdAss
FbcReactionAllowedAttributes = _libsbml.FbcReactionAllowedAttributes
FbcReactionLwrBoundSIdRef = _libsbml.FbcReactionLwrBoundSIdRef
FbcReactionUpBoundSIdRef = _libsbml.FbcReactionUpBoundSIdRef
FbcReactionLwrBoundRefExists = _libsbml.FbcReactionLwrBoundRefExists
FbcReactionUpBoundRefExists = _libsbml.FbcReactionUpBoundRefExists
FbcReactionMustHaveBoundsStrict = _libsbml.FbcReactionMustHaveBoundsStrict
FbcReactionConstantBoundsStrict = _libsbml.FbcReactionConstantBoundsStrict
FbcReactionBoundsMustHaveValuesStrict = _libsbml.FbcReactionBoundsMustHaveValuesStrict
FbcReactionBoundsNotAssignedStrict = _libsbml.FbcReactionBoundsNotAssignedStrict
FbcReactionLwrBoundNotInfStrict = _libsbml.FbcReactionLwrBoundNotInfStrict
FbcReactionUpBoundNotNegInfStrict = _libsbml.FbcReactionUpBoundNotNegInfStrict
FbcReactionLwrLessThanUpStrict = _libsbml.FbcReactionLwrLessThanUpStrict
FbcSpeciesReferenceConstantStrict = _libsbml.FbcSpeciesReferenceConstantStrict
FbcSpeciesRefsStoichMustBeRealStrict = _libsbml.FbcSpeciesRefsStoichMustBeRealStrict
FbcSpeciesRefNotAssignedStrict = _libsbml.FbcSpeciesRefNotAssignedStrict
FbcGeneProdAssocAllowedCoreAttribs = _libsbml.FbcGeneProdAssocAllowedCoreAttribs
FbcGeneProdAssocAllowedCoreElements = _libsbml.FbcGeneProdAssocAllowedCoreElements
FbcGeneProdAssocAllowedAttribs = _libsbml.FbcGeneProdAssocAllowedAttribs
FbcGeneProdAssocIdSyntax = _libsbml.FbcGeneProdAssocIdSyntax
FbcGeneProdAssocContainsOneElement = _libsbml.FbcGeneProdAssocContainsOneElement
FbcGeneProdAssocNameMustBeString = _libsbml.FbcGeneProdAssocNameMustBeString
FbcGeneProdRefAllowedCoreAttribs = _libsbml.FbcGeneProdRefAllowedCoreAttribs
FbcGeneProdRefAllowedCoreElements = _libsbml.FbcGeneProdRefAllowedCoreElements
FbcGeneProdRefAllowedAttribs = _libsbml.FbcGeneProdRefAllowedAttribs
FbcGeneProdRefGeneProductSIdRef = _libsbml.FbcGeneProdRefGeneProductSIdRef
FbcGeneProdRefGeneProductExists = _libsbml.FbcGeneProdRefGeneProductExists
FbcAndAllowedCoreAttributes = _libsbml.FbcAndAllowedCoreAttributes
FbcAndAllowedCoreElements = _libsbml.FbcAndAllowedCoreElements
FbcAndTwoChildren = _libsbml.FbcAndTwoChildren
FbcOrAllowedCoreAttributes = _libsbml.FbcOrAllowedCoreAttributes
FbcOrAllowedCoreElements = _libsbml.FbcOrAllowedCoreElements
FbcOrTwoChildren = _libsbml.FbcOrTwoChildren
FbcGeneProductAllowedCoreAttributes = _libsbml.FbcGeneProductAllowedCoreAttributes
FbcGeneProductAllowedCoreElements = _libsbml.FbcGeneProductAllowedCoreElements
FbcGeneProductAllowedAttributes = _libsbml.FbcGeneProductAllowedAttributes
FbcGeneProductLabelMustBeString = _libsbml.FbcGeneProductLabelMustBeString
FbcGeneProductLabelMustBeUnique = _libsbml.FbcGeneProductLabelMustBeUnique
FbcGeneProductNameMustBeString = _libsbml.FbcGeneProductNameMustBeString
FbcGeneProductAssocSpeciesMustExist = _libsbml.FbcGeneProductAssocSpeciesMustExist
class FbcReactionPlugin(SBasePlugin):
    """

    [SBML 'fbc' package]  Extension of Reaction by the "fbc" package.

    The FbcReactionPlugin class inherits from the SBasePlugin class, and
    codifies the extentions to the Reaction class defined in the Flux
    Balance Constraints package ("fbc").  This extention allows the
    modeler to define (in Version 2 of the "fbc" package) an upper and
    lower flux bound, with the 'upperFluxBound' and 'lowerFluxBound'
    attributes, as well as a way to reference any GeneProduct associated
    with this Reaction, through the GeneProductAssociation child.

    Note: In Version 1 of "fbc", the FluxBound element is used instead
    of the 'upperFluxBound' and 'lowerFluxBound' attributes. There is no
    equivalent of the GeneProductAssociation, which was added  in Version
    2.

    """

    __swig_setmethods__ = {}
    for _s in [SBasePlugin]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FbcReactionPlugin, name, value)
    __swig_getmethods__ = {}
    for _s in [SBasePlugin]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, FbcReactionPlugin, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(FbcReactionPlugin self, string uri, string prefix, FbcPkgNamespaces fbcns) -> FbcReactionPlugin
        __init__(FbcReactionPlugin self, FbcReactionPlugin orig) -> FbcReactionPlugin


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            FbcReactionPlugin(FbcReactionPlugin orig)

        Copy constructor for FbcReactionPlugin.

        Parameter 'orig' is the FbcReactionPlugin instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            FbcReactionPlugin(string uri, string prefix, FbcPkgNamespaces
        fbcns)

        Creates a new FbcReactionPlugin object using the given parameters.

        In the XML representation of an SBML document, XML namespaces are
        used to identify the origin of each XML construct used.  XML
        namespaces are identified by their unique resource identifiers (URIs).
        The core SBML specifications stipulate the namespaces that must be
        used for core SBML constructs; for example, all XML elements that
        belong to SBML Level 3 Version 1 Core must be placed in the XML
        namespace identified by the URI
        'http://www.sbml.org/sbml/level3/version1/core'.  Individual SBML
        Level 3 packages define their own XML namespaces; for example, all
        elements belonging to the SBML Level 3 Layout Version 1 package must
        be placed in the XML namespace
        'http://www.sbml.org/sbml/level3/version1/layout/version1/'.

        The SBMLNamespaces object encapsulates SBML Level/Version/namespaces
        information.  It is used to communicate the SBML Level, Version, and
        (in Level 3) packages used in addition to SBML Level 3 Core.  A common
        approach to using libSBML's SBMLNamespaces facilities is to create an
        SBMLNamespaces object somewhere in a program once, then hand that
        object as needed to object constructors that accept SBMLNamespaces as
        arguments.

        Parameter 'uri' is the URI of the SBML Level 3 package implemented by
        this libSBML package extension.

        Parameter 'prefix' is the XML namespace prefix being used for the
        package.

        Parameter 'fbcns' is the namespaces object for the package.

        """
        this = _libsbml.new_FbcReactionPlugin(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(FbcReactionPlugin self) -> FbcReactionPlugin


        Creates and returns a deep copy of this FbcReactionPlugin object.

        Returns a (deep) copy of this FbcReactionPlugin object.

        """
        return _libsbml.FbcReactionPlugin_clone(self)

    __swig_destroy__ = _libsbml.delete_FbcReactionPlugin
    __del__ = lambda self: None

    def createObject(self, stream):
        """
        createObject(FbcReactionPlugin self, XMLInputStream stream) -> SBase


        Internal implementation method.

        """
        return _libsbml.FbcReactionPlugin_createObject(self, stream)


    def addExpectedAttributes(self, attributes):
        """
        addExpectedAttributes(FbcReactionPlugin self, ExpectedAttributes & attributes)


        Internal implementation method.

        """
        return _libsbml.FbcReactionPlugin_addExpectedAttributes(self, attributes)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(FbcReactionPlugin self, string oldid, string newid)


        Replaces all uses of a given 'SIdRef' type attribute value with
        another value.

        In SBML, object identifiers are of a data type called SId. In SBML
        Level 3, an explicit data type called SIdRef was introduced for
        attribute values that refer to SId values; in previous Levels of SBML,
        this data type did not exist and attributes were simply described to
        as 'referring to an identifier', but the effective data type was the
        same as SIdRef in Level 3.  These and other methods of libSBML refer
        to the type SIdRef for all Levels of SBML, even if the corresponding
        SBML specification did not explicitly name the data type.

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas in MathML content, comparing the referenced
        identifiers to the value of 'oldid'.  If any matches are found, the
        matching values are replaced with 'newid'.  The method does not
        descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.FbcReactionPlugin_renameSIdRefs(self, oldid, newid)


    def readAttributes(self, attributes, expectedAttributes):
        """
        readAttributes(FbcReactionPlugin self, XMLAttributes attributes, ExpectedAttributes const & expectedAttributes)


        Internal implementation method.

        """
        return _libsbml.FbcReactionPlugin_readAttributes(self, attributes, expectedAttributes)


    def writeAttributes(self, stream):
        """
        writeAttributes(FbcReactionPlugin self, XMLOutputStream stream)


        Internal implementation method.

        """
        return _libsbml.FbcReactionPlugin_writeAttributes(self, stream)


    def getGeneProductAssociation(self, *args):
        """
        getGeneProductAssociation(FbcReactionPlugin self) -> GeneProductAssociation
        getGeneProductAssociation(FbcReactionPlugin self) -> GeneProductAssociation


        Returns the GeneProductAssociation from this FbcReactionPlugin object.

        Note: GeneProduct objects are only defined for version 2 of the 'Flux
        Balance Constraints' specification, and have no equivalent in version
        1 of the specification.

        Returns the GeneProductAssociation from object in this
        FbcReactionPlugin object.

        """
        return _libsbml.FbcReactionPlugin_getGeneProductAssociation(self, *args)


    def isSetGeneProductAssociation(self):
        """
        isSetGeneProductAssociation(FbcReactionPlugin self) -> bool


        Predicate returning 'True' if this FbcReactionPlugin's
        'GeneProductAssociation' element has been set.

        Note: GeneProduct objects are only defined for version 2 of the 'Flux
        Balance Constraints' specification, and have no equivalent in version
        1 of the specification.

        Returns 'True' if the 'GeneProductAssociation' element has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.FbcReactionPlugin_isSetGeneProductAssociation(self)


    def setGeneProductAssociation(self, geneProductAssociation):
        """
        setGeneProductAssociation(FbcReactionPlugin self, GeneProductAssociation geneProductAssociation) -> int


        Sets the GeneProductAssociation element in this FbcReactionPlugin
        object.

        Note: GeneProduct objects are only defined for version 2 of the 'Flux
        Balance Constraints' specification, and have no equivalent in version
        1 of the specification.

        Parameter 'geneProductAssociation' is the geneProductAssociation to be
        set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.FbcReactionPlugin_setGeneProductAssociation(self, geneProductAssociation)


    def createGeneProductAssociation(self):
        """
        createGeneProductAssociation(FbcReactionPlugin self) -> GeneProductAssociation


        Creates a new GeneProductAssociation object and adds it to the
        FbcReactionPlugin object.

        Note: GeneProduct objects are only defined for version 2 of the 'Flux
        Balance Constraints' specification, and have no equivalent in version
        1 of the specification.

        Returns the newly created GeneProductAssociation object.

        """
        return _libsbml.FbcReactionPlugin_createGeneProductAssociation(self)


    def getLowerFluxBound(self):
        """
        getLowerFluxBound(FbcReactionPlugin self) -> string


        Returns the value of the 'lowerFluxBound' attribute of this
        FbcReactionPlugin.

        Note: The 'upperFluxBound' and 'lowerFluxBound' attributes of the
        FbcReactionPlugin are only defined for version 2 of the 'Flux  Balance
        Constraints' specification.  In version 1, this information was
        encoded in the FluxBound children of the FbcModelPlugin.

        Returns the value of the 'lowerFluxBound' attribute of this
        FbcReactionPlugin as a string.

        """
        return _libsbml.FbcReactionPlugin_getLowerFluxBound(self)


    def getUpperFluxBound(self):
        """
        getUpperFluxBound(FbcReactionPlugin self) -> string


        Returns the value of the 'upperFluxBound' attribute of this
        FbcReactionPlugin.

        Note: The 'upperFluxBound' and 'lowerFluxBound' attributes of the
        FbcReactionPlugin are only defined for version 2 of the 'Flux  Balance
        Constraints' specification.  In version 1, this information was
        encoded in the FluxBound children of the FbcModelPlugin.

        Returns the value of the 'upperFluxBound' attribute of this
        FbcReactionPlugin as a string.

        """
        return _libsbml.FbcReactionPlugin_getUpperFluxBound(self)


    def isSetLowerFluxBound(self):
        """
        isSetLowerFluxBound(FbcReactionPlugin self) -> bool


        Predicate returning 'True' if this FbcReactionPlugin's
        'lowerFluxBound' attribute is set.

        Note: The 'upperFluxBound' and 'lowerFluxBound' attributes of the
        FbcReactionPlugin are only defined for version 2 of the 'Flux  Balance
        Constraints' specification.  In version 1, this information was
        encoded in the FluxBound children of the FbcModelPlugin.

        Returns 'True' if this FbcReactionPlugin's 'lowerFluxBound' attribute
        has been set, otherwise 'False' is returned.

        """
        return _libsbml.FbcReactionPlugin_isSetLowerFluxBound(self)


    def isSetUpperFluxBound(self):
        """
        isSetUpperFluxBound(FbcReactionPlugin self) -> bool


        Predicate returning 'True' if this FbcReactionPlugin's
        'upperFluxBound' attribute is set.

        Note: The 'upperFluxBound' and 'lowerFluxBound' attributes of the
        FbcReactionPlugin are only defined for version 2 of the 'Flux  Balance
        Constraints' specification.  In version 1, this information was
        encoded in the FluxBound children of the FbcModelPlugin.

        Returns 'True' if this FbcReactionPlugin's 'upperFluxBound' attribute
        has been set, otherwise 'False' is returned.

        """
        return _libsbml.FbcReactionPlugin_isSetUpperFluxBound(self)


    def setLowerFluxBound(self, lowerFluxBound):
        """
        setLowerFluxBound(FbcReactionPlugin self, string lowerFluxBound) -> int


        Sets the value of the 'lowerFluxBound' attribute of this
        FbcReactionPlugin.

        Note: The 'upperFluxBound' and 'lowerFluxBound' attributes of the
        FbcReactionPlugin are only defined for version 2 of the 'Flux  Balance
        Constraints' specification.  In version 1, this information was
        encoded in the FluxBound children of the FbcModelPlugin.

        Parameter 'lowerFluxBound' is the value of the 'lowerFluxBound'
        attribute to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.FbcReactionPlugin_setLowerFluxBound(self, lowerFluxBound)


    def setUpperFluxBound(self, upperFluxBound):
        """
        setUpperFluxBound(FbcReactionPlugin self, string upperFluxBound) -> int


        Sets the value of the 'upperFluxBound' attribute of this
        FbcReactionPlugin.

        Note: The 'upperFluxBound' and 'lowerFluxBound' attributes of the
        FbcReactionPlugin are only defined for version 2 of the 'Flux  Balance
        Constraints' specification.  In version 1, this information was
        encoded in the FluxBound children of the FbcModelPlugin.

        Parameter 'upperFluxBound' is the value of the 'upperFluxBound'
        attribute to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.FbcReactionPlugin_setUpperFluxBound(self, upperFluxBound)


    def unsetLowerFluxBound(self):
        """
        unsetLowerFluxBound(FbcReactionPlugin self) -> int


        Unsets the value of the 'lowerFluxBound' attribute of this
        FbcReactionPlugin.

        Note: The 'upperFluxBound' and 'lowerFluxBound' attributes of the
        FbcReactionPlugin are only defined for version 2 of the 'Flux  Balance
        Constraints' specification.  In version 1, this information was
        encoded in the FluxBound children of the FbcModelPlugin.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.FbcReactionPlugin_unsetLowerFluxBound(self)


    def unsetUpperFluxBound(self):
        """
        unsetUpperFluxBound(FbcReactionPlugin self) -> int


        Unsets the value of the 'upperFluxBound' attribute of this
        FbcReactionPlugin.

        Note: The 'upperFluxBound' and 'lowerFluxBound' attributes of the
        FbcReactionPlugin are only defined for version 2 of the 'Flux  Balance
        Constraints' specification.  In version 1, this information was
        encoded in the FluxBound children of the FbcModelPlugin.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.FbcReactionPlugin_unsetUpperFluxBound(self)


    def unsetGeneProductAssociation(self):
        """
        unsetGeneProductAssociation(FbcReactionPlugin self) -> int


        Unsets the the 'geneProduct' element of this FbcReactionPlugin.

        Note: The 'upperFluxBound' and 'lowerFluxBound' attributes of the
        FbcReactionPlugin are only defined for version 2 of the 'Flux  Balance
        Constraints' specification.  In version 1, this information was
        encoded in the FluxBound children of the FbcModelPlugin.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.FbcReactionPlugin_unsetGeneProductAssociation(self)


    def connectToParent(self, sbase):
        """
        connectToParent(FbcReactionPlugin self, SBase sbase)


        Internal implementation method.

        """
        return _libsbml.FbcReactionPlugin_connectToParent(self, sbase)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(FbcReactionPlugin self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.FbcReactionPlugin_enablePackageInternal(self, pkgURI, pkgPrefix, flag)

FbcReactionPlugin_swigregister = _libsbml.FbcReactionPlugin_swigregister
FbcReactionPlugin_swigregister(FbcReactionPlugin)

class FbcAssociation(SBase):
    """

    [SBML 'fbc' package]  Base class for FbcAnd, FbcOr, and
    GeneProductRef

    The FbcAssociation class is the abstract base class for the classes
    that can be used as children of the GeneProductAssociation child of a
    Reaction. The FbcAnd class is used when all of its children are
    definitely associated with the Reaction; the FbcOr class is used when
    at least one of its children are associated with the Reaction; and the
    GeneProductRef class is used to denote a particular GeneProduct.

    Note: This class of objects was introduced in Version 2 of the SBML
    Level 3 Flux Balance Constraints ("fbc") specification.  In Version
    1 of "fbc", the information encoded by this class can be stored
    instead using the Association and GeneAssociation annotation classes.
    Please see the Version 1 and Version 2 "fbc" specifications for more
    details.

    See also ListOfFbcAssociations, FbcAnd, FbcOr, GeneProductRef.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FbcAssociation, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, FbcAssociation, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(FbcAssociation self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> FbcAssociation
        __init__(FbcAssociation self, unsigned int level, unsigned int version) -> FbcAssociation
        __init__(FbcAssociation self, unsigned int level) -> FbcAssociation
        __init__(FbcAssociation self) -> FbcAssociation
        __init__(FbcAssociation self, FbcPkgNamespaces fbcns) -> FbcAssociation
        __init__(FbcAssociation self, FbcAssociation orig) -> FbcAssociation


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            FbcAssociation(long level      =
        FbcExtension.getDefaultLevel(), long version    =
        FbcExtension.getDefaultVersion(), long pkgVersion =
        FbcExtension.getDefaultPackageVersion())

        Creates a new FbcAssociation with the given SBML Level, Version, and
        "fbc"package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        FbcAssociation.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this FbcAssociation.

        Parameter 'pkgVersion' is a long integer, the SBML "fbc" package
        Version to assign to this FbcAssociation.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            FbcAssociation(FbcAssociation orig)

        Copy constructor for FbcAssociation.

        Parameter 'orig' is the FbcAssociation instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            FbcAssociation(FbcPkgNamespaces fbcns)

        Creates a new FbcAssociation with the given FbcPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'fbcns' is the FbcPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_FbcAssociation(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(FbcAssociation self) -> FbcAssociation


        Creates and returns a deep copy of this FbcAssociation object.

        Returns a (deep) copy of this FbcAssociation object.

        """
        return _libsbml.FbcAssociation_clone(self)

    __swig_destroy__ = _libsbml.delete_FbcAssociation
    __del__ = lambda self: None

    def isFbcAnd(self):
        """
        isFbcAnd(FbcAssociation self) -> bool


        Returns 'True,' if this abstract FbcAssociation is of type FbcAnd.

        Returns 'True,' if this abstract FbcAssociation is of type FbcAnd.

        """
        return _libsbml.FbcAssociation_isFbcAnd(self)


    def isFbcOr(self):
        """
        isFbcOr(FbcAssociation self) -> bool


        Returns 'True,' if this abstract FbcAssociation is of type FbcOr.

        Returns 'True,' if this abstract FbcAssociation is of type FbcOr.

        """
        return _libsbml.FbcAssociation_isFbcOr(self)


    def isGeneProductRef(self):
        """
        isGeneProductRef(FbcAssociation self) -> bool


        Returns 'True,' if this abstract FbcAssociation is of type
        GeneProductRef.

        Returns 'True,' if this abstract FbcAssociation is of type
        GeneProductRef.

        """
        return _libsbml.FbcAssociation_isGeneProductRef(self)


    def getElementName(self):
        """
        getElementName(FbcAssociation self) -> string


        Returns the XML element name of this object.

        For FbcAssociation, the XML element name is always ''fbcAssociation'.'

        Returns the name of this element, i.e. ''fbcAssociation'.'

        """
        return _libsbml.FbcAssociation_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(FbcAssociation self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_FBC_ASSOCIATION
        (default).

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.FbcAssociation_getTypeCode(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(FbcAssociation self) -> bool


        Predicate returning 'True' if all the required attributes for this
        FbcAssociation object have been set.

        Note: FbcAssociation has no required attributes, so this method always
        returns 'True.'

        Returns a boolean value indicating whether all the required attributes
        for this object have been defined.

        """
        return _libsbml.FbcAssociation_hasRequiredAttributes(self)


    def parseFbcInfixAssociation(association, plugin, usingId=False, addMissingGP=True):
        """
        parseFbcInfixAssociation(string association, FbcModelPlugin plugin, bool usingId=False, bool addMissingGP=True) -> FbcAssociation
        parseFbcInfixAssociation(string association, FbcModelPlugin plugin, bool usingId=False) -> FbcAssociation
        parseFbcInfixAssociation(string association, FbcModelPlugin plugin) -> FbcAssociation


        Parses a gene association in infix format and returns a corresponding
        Association object.

        This parses a string that has a list of gene names and conjunctions or
        disjunctions.  For example:

            (b2422) and (b2425) and (b2423) and (b2424) or (b2422) and (b2423) and (b2424) and (b2413) and (b3917)

        The 'and' operator takes precedence over the 'or' operator, meaning
        that the above input string would turn into two groups of gene names:
        either 'b2422, b2425, b2423, and b2424' or 'b2422, b2423, b2424,
        b2413, and b3917'. Parentheses may be added to make things more clear,
        and to encode alternative schemes.

        This method also creates missing GeneProduct objects, in case the
        unique reference does not yet exist.

        Parameter 'association' is the string to parse. Parameter 'plugin' is
        the FbcModelPlugin on which to add the geneProduct elements. Parameter
        'usingId' is boolean indicating whether the infix assumes identifiers
        ('True)' or labels ('False' default). Parameter 'addMissingGP' is
        boolean indicating whether to add missing geneProducts  ('True'
        default) or not ('False).'

        Returns the parsed association, or 'None' in case of an error.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.FbcAssociation_parseFbcInfixAssociation(association, plugin, usingId, addMissingGP)

    parseFbcInfixAssociation = staticmethod(parseFbcInfixAssociation)

    def toInfix(self, usingId=False):
        """
        toInfix(FbcAssociation self, bool usingId=False) -> string
        toInfix(FbcAssociation self) -> string


        Converts this FbcAssociation object into an infix string
        representation.

        Returns the association as infix string.

        """
        return _libsbml.FbcAssociation_toInfix(self, usingId)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(FbcAssociation self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.FbcAssociation_enablePackageInternal(self, pkgURI, pkgPrefix, flag)

FbcAssociation_swigregister = _libsbml.FbcAssociation_swigregister
FbcAssociation_swigregister(FbcAssociation)

def FbcAssociation_parseFbcInfixAssociation(association, plugin, usingId=False, addMissingGP=True):
    """
    parseFbcInfixAssociation(string association, FbcModelPlugin plugin, bool usingId=False, bool addMissingGP=True) -> FbcAssociation
    parseFbcInfixAssociation(string association, FbcModelPlugin plugin, bool usingId=False) -> FbcAssociation
    FbcAssociation_parseFbcInfixAssociation(string association, FbcModelPlugin plugin) -> FbcAssociation


    Parses a gene association in infix format and returns a corresponding
    Association object.

    This parses a string that has a list of gene names and conjunctions or
    disjunctions.  For example:

        (b2422) and (b2425) and (b2423) and (b2424) or (b2422) and (b2423) and (b2424) and (b2413) and (b3917)

    The 'and' operator takes precedence over the 'or' operator, meaning
    that the above input string would turn into two groups of gene names:
    either 'b2422, b2425, b2423, and b2424' or 'b2422, b2423, b2424,
    b2413, and b3917'. Parentheses may be added to make things more clear,
    and to encode alternative schemes.

    This method also creates missing GeneProduct objects, in case the
    unique reference does not yet exist.

    Parameter 'association' is the string to parse. Parameter 'plugin' is
    the FbcModelPlugin on which to add the geneProduct elements. Parameter
    'usingId' is boolean indicating whether the infix assumes identifiers
    ('True)' or labels ('False' default). Parameter 'addMissingGP' is
    boolean indicating whether to add missing geneProducts  ('True'
    default) or not ('False).'

    Returns the parsed association, or 'None' in case of an error.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.FbcAssociation_parseFbcInfixAssociation(association, plugin, usingId, addMissingGP)

class ListOfFbcAssociations(ListOf):
    """

    [SBML 'fbc' package]  A list of FbcAssociation objects.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    The ListOfFbcAssociations is a container of FbcAssociation objects
    for the FbcAnd and FbcOr classes.  Unlike the ListOf___ classes in
    SBML, the ListOfFbcAssociations is not a class that appears in the
    "fbc" Version 2 specification, and instead is used internally in
    libSBML as a convenience class to store arbitrary numbers of
    FbcAssociation objects. Also unlike other ListOf___ classes, the
    FbcAnd and FbcOr classes require at least two child FbcAssociation
    objects, so valid ListOfFbcAssociations libsbml objects will always
    contain two or more children.  These children will have element names
    associated with their derived class, not the base FbcAssociation
    class: <fbc:and>, <fbc:or>, and <fbc:geneProductRef>.

    Note: This class of objects was introduced in Version 2 of the SBML
    Level 3 Flux Balance Constraints ("fbc") specification.  In Version
    1 of "fbc", the information encoded by this class can be stored
    instead using the Association and GeneAssociation annotation classes.
    Please see the Version 1 and Version 2 "fbc" specifications for more
    details.

    WARNING:

    It is important to be clear that ListOfFbcAssociations is not written
    out in the XML output produced by libSBML -- the constructs only exist
    in software to enable software applications to manipulate
    FbcAssociation objects in a way that mirrors how other lists of
    components in SBML are manipulated.  ListOfFbcAssociations is
    abstracted away when an SBML "fbc" model file is actually written
    out in the final XML form.

    See also FbcAssociation, FbcAnd, FbcOr, GeneProductRef.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfFbcAssociations, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfFbcAssociations, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ListOfFbcAssociations self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ListOfFbcAssociations
        __init__(ListOfFbcAssociations self, unsigned int level, unsigned int version) -> ListOfFbcAssociations
        __init__(ListOfFbcAssociations self, unsigned int level) -> ListOfFbcAssociations
        __init__(ListOfFbcAssociations self) -> ListOfFbcAssociations
        __init__(ListOfFbcAssociations self, FbcPkgNamespaces fbcns) -> ListOfFbcAssociations


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfFbcAssociations(long level      =
        FbcExtension.getDefaultLevel(), long version    =
        FbcExtension.getDefaultVersion(), long pkgVersion =
        FbcExtension.getDefaultPackageVersion())

        Creates a new ListOfFbcAssociations with the given SBML Level,
        Version, and "fbc"package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        ListOfFbcAssociations.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this ListOfFbcAssociations.

        Parameter 'pkgVersion' is a long integer, the SBML "fbc" package
        Version to assign to this ListOfFbcAssociations.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfFbcAssociations(FbcPkgNamespaces fbcns)

        Creates a new ListOfFbcAssociations with the given FbcPkgNamespaces
        object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'fbcns' is the FbcPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_ListOfFbcAssociations(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ListOfFbcAssociations self) -> ListOfFbcAssociations


        Creates and returns a deep copy of this ListOfFbcAssociations object.

        Returns a (deep) copy of this ListOfFbcAssociations object.

        """
        return _libsbml.ListOfFbcAssociations_clone(self)


    def get(self, *args):
        """
        get(ListOfFbcAssociations self, unsigned int n) -> FbcAssociation
        get(ListOfFbcAssociations self, unsigned int n) -> FbcAssociation
        get(ListOfFbcAssociations self, string sid) -> FbcAssociation
        get(ListOfFbcAssociations self, string sid) -> FbcAssociation


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a FbcAssociation from the ListOfFbcAssociations.

        Parameter 'n' is the index number of the FbcAssociation to get.

        Returns the nth FbcAssociation in this ListOfFbcAssociations. If the
        index 'n' is invalid, 'None' is returned.

        See also size(), getNumFbcAssociations().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a FbcAssociation from the ListOfFbcAssociations based on its
        identifier.

        Parameter 'sid' is a string representing the identifier of the
        FbcAssociation to get.

        Returns FbcAssociation in this ListOfFbcAssociations with the given id
        or 'None' if no such FbcAssociation exists.

        See also get(), size().

        """
        return _libsbml.ListOfFbcAssociations_get(self, *args)


    def addFbcAssociation(self, fa):
        """
        addFbcAssociation(ListOfFbcAssociations self, FbcAssociation fa) -> int


        Adds a copy the given FbcAssociation object to this
        ListOfFbcAssociations.

        Parameter 'fa' is the FbcAssociation object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.ListOfFbcAssociations_addFbcAssociation(self, fa)


    def getNumFbcAssociations(self):
        """
        getNumFbcAssociations(ListOfFbcAssociations self) -> unsigned int


        Get the number of FbcAssociation objects in this
        ListOfFbcAssociations.

        Returns the number of FbcAssociation objects in this
        ListOfFbcAssociations.

        """
        return _libsbml.ListOfFbcAssociations_getNumFbcAssociations(self)


    def createAnd(self):
        """
        createAnd(ListOfFbcAssociations self) -> FbcAnd


        Creates a new FbcAnd object.

        This method creates a new FbcAssociation object of subclass FbcAnd,
        adds it to the ListOfFbcAssociations, and returns the FbcAssociation
        object created.

        Returns a new FbcAssociation object instance.

        See also createOr(), createGeneProductRef(), addFbcAssociation().

        """
        return _libsbml.ListOfFbcAssociations_createAnd(self)


    def createOr(self):
        """
        createOr(ListOfFbcAssociations self) -> FbcOr


        Creates a new FbcOr object.

        This method creates a new FbcAssociation object of subclass FbcOr,
        adds it to the ListOfFbcAssociations, and returns the FbcAssociation
        object created.

        Returns a new FbcAssociation object instance.

        See also createAnd(), createGeneProductRef(), addFbcAssociation().

        """
        return _libsbml.ListOfFbcAssociations_createOr(self)


    def createGeneProductRef(self):
        """
        createGeneProductRef(ListOfFbcAssociations self) -> GeneProductRef


        Creates a new GeneProductRef object.

        This method creates a new FbcAssociation object of subclass
        GeneProductRef, adds it to the ListOfFbcAssociations, and returns the
        FbcAssociation object created.

        Returns a new FbcAssociation object instance.

        See also createOr(), createAnd(), addFbcAssociation().

        """
        return _libsbml.ListOfFbcAssociations_createGeneProductRef(self)


    def remove(self, *args):
        """
        remove(ListOfFbcAssociations self, unsigned int n) -> FbcAssociation
        remove(ListOfFbcAssociations self, string sid) -> FbcAssociation


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth FbcAssociation

        This method removes the nth object from this ListOfFbcAssociations and
        returns a pointer to it.

        Parameter 'n' is the index of the FbcAssociation to remove.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes the FbcAssociation with the given identifier

        This method searches for and removes the FbcAssociation object with
        the given identifier 'sid', and returns a pointer to it.  The caller
        owns the returned item and is responsible for deleting it.  If none of
        the items in this list have the identifier 'sid', then 'None' is
        returned.

        Parameter 'sid' is the identifier of the FbcAssociation to remove.

        Returns the FbcAssociation removed. As mentioned above, the caller
        owns the returned item.

        """
        return _libsbml.ListOfFbcAssociations_remove(self, *args)


    def getElementName(self):
        """
        getElementName(ListOfFbcAssociations self) -> string


        Returns the XML element name of this object.

        For ListOfFbcAssociations, the XML element name is always
        ''listOfFbcAssociations'.'

        Returns the name of this element.

        """
        return _libsbml.ListOfFbcAssociations_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(ListOfFbcAssociations self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_LIST_OF (default).

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfFbcAssociations_getTypeCode(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfFbcAssociations self) -> int


        Returns the libSBML type code for the objects contained in this
        ListOf.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for the objects contained in this ListOf
        instance: SBML_FBC_ASSOCIATION (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfFbcAssociations_getItemTypeCode(self)

    __swig_destroy__ = _libsbml.delete_ListOfFbcAssociations
    __del__ = lambda self: None
ListOfFbcAssociations_swigregister = _libsbml.ListOfFbcAssociations_swigregister
ListOfFbcAssociations_swigregister(ListOfFbcAssociations)

class GeneProductAssociation(SBase):
    """

    [SBML 'fbc' package]  Association between gene products and
    reactions

    In Version 2 of the SBML Level 3 Flux Balance Constraints ("fbc")
    package specification, GeneProductAssociation is a class derived from
    SBase used to associate one more genes or gene products with
    reactions. GeneProductAssociation objects are essentially containers,
    with one such container optionally attached as a subelement to a
    Reaction object in a model.  The container can contain one of three
    kinds of objects, all of which are subclasses of the libSBML parent
    class FbcAssociation.  (Note that this class is named Association in
    the "fbc" Version 2 specification, but in libSBML is named
    FbcAssociation to avoid a name conflict with an existing class.)

    One of the kinds of FbcAssociation subclasses that can appear in a
    GeneProductAssociation is GeneProductRef.  This class of objects
    references a GeneProduct declared in a ListOfGeneProducts attached to
    the enclosing Model object.  In the "fbc" approach, when more than
    one gene (or gene product) is present in an association, they are
    written as logical expressions using Boolean logical operators and and
    or through the classes (in libSBML) FbcAnd and FbcOr.  (In the "fbc"
    Version 2 specification, these are simply named And and Or,
    respectively.) The FbcAnd and FbcOr objects in turn can contain either
    GeneProductRef objects or other FbcAnd and/or FbcOr objects.

    Here is a concrete example of what the XML representation of a simple
    or relationship might look like:

      <reaction id = 'R_ABTA' ... rest of Reaction declaration elided for this example ...>
       <fbc:geneProductAssociation fbc:id='ga_16'>
        <fbc:or>
         <fbc:geneProductRef fbc:geneProduct='g_b2662'/>
         <fbc:geneProductRef fbc:geneProduct='g_b1302'/>
        </fbc:or>
       </fbc:geneProductAssociationgt;
      </reaction>

    Note: This class of objects was introduced in Version 2 of the SBML
    Level 3 Flux Balance Constraints ("fbc") specification.  In Version
    1 of "fbc", the information encoded by this class can be stored
    instead using the Association and GeneAssociation annotation classes.
    Please see the Version 1 and Version 2 "fbc" specifications for more
    details.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GeneProductAssociation, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, GeneProductAssociation, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(GeneProductAssociation self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> GeneProductAssociation
        __init__(GeneProductAssociation self, unsigned int level, unsigned int version) -> GeneProductAssociation
        __init__(GeneProductAssociation self, unsigned int level) -> GeneProductAssociation
        __init__(GeneProductAssociation self) -> GeneProductAssociation
        __init__(GeneProductAssociation self, FbcPkgNamespaces fbcns) -> GeneProductAssociation
        __init__(GeneProductAssociation self, GeneProductAssociation orig) -> GeneProductAssociation


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            GeneProductAssociation(long level      =
        FbcExtension.getDefaultLevel(), long version    =
        FbcExtension.getDefaultVersion(), long pkgVersion =
        FbcExtension.getDefaultPackageVersion())

        Creates a new GeneProductAssociation with the given SBML Level,
        Version, and "fbc" package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        GeneProductAssociation.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this GeneProductAssociation.

        Parameter 'pkgVersion' is a long integer, the SBML "fbc" Version to
        assign to this GeneProductAssociation object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            GeneProductAssociation(GeneProductAssociation orig)

        Copy constructor for GeneProductAssociation.

        Parameter 'orig' is the GeneProductAssociation instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            GeneProductAssociation(FbcPkgNamespaces fbcns)

        Creates a new GeneProductAssociation with the given FbcPkgNamespaces
        object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'fbcns' is the FbcPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_GeneProductAssociation(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(GeneProductAssociation self) -> GeneProductAssociation


        Creates and returns a deep copy of this GeneProductAssociation object.

        Returns a (deep) copy of this GeneProductAssociation object.

        """
        return _libsbml.GeneProductAssociation_clone(self)

    __swig_destroy__ = _libsbml.delete_GeneProductAssociation
    __del__ = lambda self: None

    def getId(self):
        """
        getId(GeneProductAssociation self) -> string


        Returns the value of the 'id' attribute of this
        GeneProductAssociation.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is now recommended to use the
        getIdAttribute() function instead.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns the id of this GeneProductAssociation.

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.GeneProductAssociation_getId(self)


    def getName(self):
        """
        getName(GeneProductAssociation self) -> string


        Returns the value of the 'name' attribute of this
        GeneProductAssociation object.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns the name of this SBML object, or the empty string if not set
        or unsettable.

        See also getIdAttribute(), isSetName(), setName(), unsetName().

        """
        return _libsbml.GeneProductAssociation_getName(self)


    def getAssociation(self, *args):
        """
        getAssociation(GeneProductAssociation self) -> FbcAssociation
        getAssociation(GeneProductAssociation self) -> FbcAssociation


        Returns the 'association' element of this GeneProductAssociation.

        Returns the 'association' element of this GeneProductAssociation.

        """
        return _libsbml.GeneProductAssociation_getAssociation(self, *args)


    def createAnd(self):
        """
        createAnd(GeneProductAssociation self) -> FbcAnd


        Creates a new 'association' and sets it for this
        GeneProductAssociation.

        Returns the FbcAnd created.

        """
        return _libsbml.GeneProductAssociation_createAnd(self)


    def createOr(self):
        """
        createOr(GeneProductAssociation self) -> FbcOr


        Creates a new 'association' and sets it for this
        GeneProductAssociation.

        """
        return _libsbml.GeneProductAssociation_createOr(self)


    def createGeneProductRef(self):
        """
        createGeneProductRef(GeneProductAssociation self) -> GeneProductRef


        Creates a new 'association' and sets it for this
        GeneProductAssociation.

        """
        return _libsbml.GeneProductAssociation_createGeneProductRef(self)


    def isSetId(self):
        """
        isSetId(GeneProductAssociation self) -> bool


        Predicate returning 'True' if this GeneProductAssociation's 'id'
        attribute is set.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns 'True' if the 'id' attribute of this SBML object is set,
        'False' otherwise.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is recommended that callers use
        isSetIdAttribute() instead.

        See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(),
        isSetIdAttribute().

        """
        return _libsbml.GeneProductAssociation_isSetId(self)


    def isSetName(self):
        """
        isSetName(GeneProductAssociation self) -> bool


        Predicate returning 'True' if this GeneProductAssociation's 'name'
        attribute is set.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns 'True' if the 'name' attribute of this SBML object is set,
        'False' otherwise.

        See also getName(), setName(), unsetName().

        """
        return _libsbml.GeneProductAssociation_isSetName(self)


    def isSetAssociation(self):
        """
        isSetAssociation(GeneProductAssociation self) -> bool


        Predicate returning 'True' if this GeneProductAssociation's
        'association' element is set.

        Returns 'True' if this GeneProductAssociation's 'association' element
        has been set, otherwise 'False' is returned.

        """
        return _libsbml.GeneProductAssociation_isSetAssociation(self)


    def setId(self, sid):
        """
        setId(GeneProductAssociation self, string sid) -> int


        Sets the value of the 'id' attribute of this GeneProductAssociation.

        The string 'sid' is copied.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Parameter 'sid' is the string to use as the identifier of this object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.GeneProductAssociation_setId(self, sid)


    def setName(self, name):
        """
        setName(GeneProductAssociation self, string name) -> int


        Sets the value of the 'name' attribute of this GeneProductAssociation.

        The string in 'name' is copied.

        Parameter 'name' is the new name for the SBML object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.GeneProductAssociation_setName(self, name)


    def setAssociation(self, *args):
        """
        setAssociation(GeneProductAssociation self, FbcAssociation association) -> int
        setAssociation(GeneProductAssociation self, string association, bool usingId=False, bool addMissingGP=True) -> int
        setAssociation(GeneProductAssociation self, string association, bool usingId=False) -> int
        setAssociation(GeneProductAssociation self, string association) -> int


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            setAssociation(FbcAssociation association)

        Sets the 'association' element of this GeneProductAssociation.

        Parameter 'association' is FbcAssociation to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        ______________________________________________________________________
        Method variant with the following signature:

            setAssociation(string association, bool usingId = false, bool
        addMissingGP = true)

        Sets the 'association' element of this GeneProductAssociation.

        This is a helper method that allows a user to set the
        GeneProductAssociation via a string such as "a1 AND b1 OR C2" and
        have the method work out the correct XML structure.

        Parameter 'association' is string representation of the association to
        be set. Parameter 'usingId' is Parameter 'addMissingGP' is Parameter
        'usingId' is If 'True,' this method assumes that the infix string
        'association' uses the identifiers of GeneProduct objects.  If 'False'
        (the default), the method assumes that the string uses the label
        attributes of GeneProduct objects.

        Parameter 'addMissingGP' is If 'True' (the default), then while
        parsing the infix string in 'association', any identifiers or labels
        (depending on 'usingId') found in the expression that do not
        correspond to an existing GeneProduct object will result in the
        addition of that GeneProduct.  If 'False,' this method will not add a
        GeneProduct in that circumstance.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        return _libsbml.GeneProductAssociation_setAssociation(self, *args)


    def unsetId(self):
        """
        unsetId(GeneProductAssociation self) -> int


        Unsets the value of the 'id' attribute of this GeneProductAssociation.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.GeneProductAssociation_unsetId(self)


    def unsetName(self):
        """
        unsetName(GeneProductAssociation self) -> int


        Unsets the value of the 'name' attribute of this
        GeneProductAssociation.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getName(), setName(), isSetName().

        """
        return _libsbml.GeneProductAssociation_unsetName(self)


    def unsetAssociation(self):
        """
        unsetAssociation(GeneProductAssociation self) -> int


        Unsets the 'association' element of this GeneProductAssociation.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.GeneProductAssociation_unsetAssociation(self)


    def getElementName(self):
        """
        getElementName(GeneProductAssociation self) -> string


        Returns the XML element name of this object.

        For GeneProductAssociation, the XML element name is always
        ''geneProductAssociation'.'

        Returns the name of this element, i.e. ''geneProductAssociation'.'

        """
        return _libsbml.GeneProductAssociation_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(GeneProductAssociation self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object:
        SBML_FBC_GENEPRODUCTASSOCIATION (default).

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.GeneProductAssociation_getTypeCode(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(GeneProductAssociation self) -> bool


        Predicate returning 'True' if all the required attributes for this
        GeneProductAssociation object have been set.

        Note: The required attributes for a GeneProductAssociation object are:

        * 'association'

        Returns a boolean value indicating whether all the required attributes
        for this object have been defined.

        """
        return _libsbml.GeneProductAssociation_hasRequiredAttributes(self)


    def hasRequiredElements(self):
        """
        hasRequiredElements(GeneProductAssociation self) -> bool


        Predicate returning 'True' if all the required elements for this
        GeneProductAssociation object have been set.

        Note: The required elements for a GeneProductAssociation object are:

        * 'association'

        Returns a boolean value indicating whether all the required elements
        for this object have been defined.

        """
        return _libsbml.GeneProductAssociation_hasRequiredElements(self)


    def connectToChild(self):
        """
        connectToChild(GeneProductAssociation self)


        Internal implementation method.

        """
        return _libsbml.GeneProductAssociation_connectToChild(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(GeneProductAssociation self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.GeneProductAssociation_enablePackageInternal(self, pkgURI, pkgPrefix, flag)

GeneProductAssociation_swigregister = _libsbml.GeneProductAssociation_swigregister
GeneProductAssociation_swigregister(GeneProductAssociation)

class GeneProduct(SBase):
    """

    [SBML 'fbc' package]  Association of a gene product with a Reaction

    In the SBML Level 3 Flux Balance Constraints ("fbc") package
    representation format, a GeneProduct object represents a single gene
    or implied gene product.  The gene or gene product is identified using
    the required attribute 'label', which is a text string.  (This
    attribute is separate from the usual SBML 'id' attribute, which is
    used to cross-reference entities within an SBML model.)  A GeneProduct
    object can also possess an optional 'associatedSpecies' attribute; if
    this a attribute is defined, it should have a value of type SIdRef and
    be the identifier of a Species object defined in the enclosing Model.
    An 'associatedSpecies', if it exists, is interpreted to be a species
    associated with the gene or gene product that is represented by the
    GeneProduct object.

    Note: This class of objects was introduced in Version 2 of the SBML
    Level 3 Flux Balance Constraints ("fbc") specification.  In Version
    1 of "fbc", the information encoded by this class can be stored
    instead using the Association and GeneAssociation annotation classes.
    Please see the Version 1 and Version 2 "fbc" specifications for more
    details.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GeneProduct, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, GeneProduct, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(GeneProduct self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> GeneProduct
        __init__(GeneProduct self, unsigned int level, unsigned int version) -> GeneProduct
        __init__(GeneProduct self, unsigned int level) -> GeneProduct
        __init__(GeneProduct self) -> GeneProduct
        __init__(GeneProduct self, FbcPkgNamespaces fbcns) -> GeneProduct
        __init__(GeneProduct self, GeneProduct orig) -> GeneProduct


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            GeneProduct(GeneProduct orig)

        Copy constructor for GeneProduct.

        Parameter 'orig' is the GeneProduct instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            GeneProduct(long level      = FbcExtension.getDefaultLevel(),
        long version    = FbcExtension.getDefaultVersion(), long pkgVersion =
        FbcExtension.getDefaultPackageVersion())

        Creates a new GeneProduct with the given SBML Level, Version, and
        "fbc"package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        GeneProduct.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this GeneProduct.

        Parameter 'pkgVersion' is a long integer, the SBML Fbc Version to
        assign to this GeneProduct.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            GeneProduct(FbcPkgNamespaces fbcns)

        Creates a new GeneProduct with the given FbcPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'fbcns' is the FbcPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_GeneProduct(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(GeneProduct self) -> GeneProduct


        Creates and returns a deep copy of this GeneProduct object.

        Returns a (deep) copy of this GeneProduct object.

        """
        return _libsbml.GeneProduct_clone(self)

    __swig_destroy__ = _libsbml.delete_GeneProduct
    __del__ = lambda self: None

    def getId(self):
        """
        getId(GeneProduct self) -> string


        Returns the value of the 'id' attribute of this GeneProduct.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is now recommended to use the
        getIdAttribute() function instead.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns the id of this GeneProduct.

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.GeneProduct_getId(self)


    def getName(self):
        """
        getName(GeneProduct self) -> string


        Returns the value of the 'name' attribute of this GeneProduct object.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns the name of this SBML object, or the empty string if not set
        or unsettable.

        See also getIdAttribute(), isSetName(), setName(), unsetName().

        """
        return _libsbml.GeneProduct_getName(self)


    def getLabel(self):
        """
        getLabel(GeneProduct self) -> string


        Returns the value of the 'label' attribute of this GeneProduct.

        Returns the value of the 'label' attribute of this GeneProduct as a
        string.

        """
        return _libsbml.GeneProduct_getLabel(self)


    def getAssociatedSpecies(self):
        """
        getAssociatedSpecies(GeneProduct self) -> string


        Returns the value of the 'associatedSpecies' attribute of this
        GeneProduct.

        Returns the value of the 'associatedSpecies' attribute of this
        GeneProduct as a string.

        """
        return _libsbml.GeneProduct_getAssociatedSpecies(self)


    def isSetId(self):
        """
        isSetId(GeneProduct self) -> bool


        Predicate returning 'True' if this GeneProduct's 'id' attribute is
        set.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns 'True' if the 'id' attribute of this SBML object is set,
        'False' otherwise.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is recommended that callers use
        isSetIdAttribute() instead.

        See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(),
        isSetIdAttribute().

        """
        return _libsbml.GeneProduct_isSetId(self)


    def isSetName(self):
        """
        isSetName(GeneProduct self) -> bool


        Predicate returning 'True' if this GeneProduct's 'name' attribute is
        set.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns 'True' if the 'name' attribute of this SBML object is set,
        'False' otherwise.

        See also getName(), setName(), unsetName().

        """
        return _libsbml.GeneProduct_isSetName(self)


    def isSetLabel(self):
        """
        isSetLabel(GeneProduct self) -> bool


        Predicate returning 'True' if this GeneProduct's 'label' attribute is
        set.

        Returns 'True' if this GeneProduct's 'label' attribute has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.GeneProduct_isSetLabel(self)


    def isSetAssociatedSpecies(self):
        """
        isSetAssociatedSpecies(GeneProduct self) -> bool


        Predicate returning 'True' if this GeneProduct's 'associatedSpecies'
        attribute is set.

        Returns 'True' if this GeneProduct's 'associatedSpecies' attribute has
        been set, otherwise 'False' is returned.

        """
        return _libsbml.GeneProduct_isSetAssociatedSpecies(self)


    def setId(self, sid):
        """
        setId(GeneProduct self, string sid) -> int


        Sets the value of the 'id' attribute of this GeneProduct.

        The string 'sid' is copied.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Parameter 'sid' is the string to use as the identifier of this object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.GeneProduct_setId(self, sid)


    def setName(self, name):
        """
        setName(GeneProduct self, string name) -> int


        Sets the value of the 'name' attribute of this GeneProduct.

        The string in 'name' is copied.

        Parameter 'name' is the new name for the SBML object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.GeneProduct_setName(self, name)


    def setLabel(self, label):
        """
        setLabel(GeneProduct self, string label) -> int


        Sets the value of the 'label' attribute of this GeneProduct.

        Parameter 'label' is the value of the 'label' attribute to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.GeneProduct_setLabel(self, label)


    def setAssociatedSpecies(self, associatedSpecies):
        """
        setAssociatedSpecies(GeneProduct self, string associatedSpecies) -> int


        Sets the value of the 'associatedSpecies' attribute of this
        GeneProduct.

        Parameter 'associatedSpecies' is the value of the 'associatedSpecies'
        attribute to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.GeneProduct_setAssociatedSpecies(self, associatedSpecies)


    def unsetId(self):
        """
        unsetId(GeneProduct self) -> int


        Unsets the value of the 'id' attribute of this GeneProduct.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.GeneProduct_unsetId(self)


    def unsetName(self):
        """
        unsetName(GeneProduct self) -> int


        Unsets the value of the 'name' attribute of this GeneProduct.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getName(), setName(), isSetName().

        """
        return _libsbml.GeneProduct_unsetName(self)


    def unsetLabel(self):
        """
        unsetLabel(GeneProduct self) -> int


        Unsets the value of the 'label' attribute of this GeneProduct.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.GeneProduct_unsetLabel(self)


    def unsetAssociatedSpecies(self):
        """
        unsetAssociatedSpecies(GeneProduct self) -> int


        Unsets the value of the 'associatedSpecies' attribute of this
        GeneProduct.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.GeneProduct_unsetAssociatedSpecies(self)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(GeneProduct self, string oldid, string newid)


        Replaces all uses of a given 'SIdRef' type attribute value with
        another value.

        In SBML, object identifiers are of a data type called SId. In SBML
        Level 3, an explicit data type called SIdRef was introduced for
        attribute values that refer to SId values; in previous Levels of SBML,
        this data type did not exist and attributes were simply described to
        as 'referring to an identifier', but the effective data type was the
        same as SIdRef in Level 3.  These and other methods of libSBML refer
        to the type SIdRef for all Levels of SBML, even if the corresponding
        SBML specification did not explicitly name the data type.

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas in MathML content, comparing the referenced
        identifiers to the value of 'oldid'.  If any matches are found, the
        matching values are replaced with 'newid'.  The method does not
        descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.GeneProduct_renameSIdRefs(self, oldid, newid)


    def getElementName(self):
        """
        getElementName(GeneProduct self) -> string


        Returns the XML element name of this object.

        For GeneProduct, the XML element name is always ''geneProduct'.'

        Returns the name of this element, i.e. ''geneProduct'.'

        """
        return _libsbml.GeneProduct_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(GeneProduct self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_FBC_GENEPRODUCT
        (default).

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.GeneProduct_getTypeCode(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(GeneProduct self) -> bool


        Predicate returning 'True' if all the required attributes for this
        GeneProduct object have been set.

        Note: The required attributes for a GeneProduct object are:

        * 'id'

        * 'label'

        Returns a boolean value indicating whether all the required attributes
        for this object have been defined.

        """
        return _libsbml.GeneProduct_hasRequiredAttributes(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(GeneProduct self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.GeneProduct_enablePackageInternal(self, pkgURI, pkgPrefix, flag)

GeneProduct_swigregister = _libsbml.GeneProduct_swigregister
GeneProduct_swigregister(GeneProduct)

class ListOfGeneProducts(ListOf):
    """

    [SBML 'fbc' package]  A list of GeneProduct objects.

    The ListOfGeneProducts is a container for the SBML extended Model that
    lists all the possible GeneProduct elements in the model.  These
    GeneProduct elements are referenced in the GeneProductAssociation
    child of an extended Reaction.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    See also GeneProduct, FbcModelPlugin.

    Note: This class of objects was introduced in Version 2 of the SBML
    Level 3 Flux Balance Constraints ("fbc") specification.  In Version
    1 of "fbc", the information encoded by this class can be stored
    instead using the Association and GeneAssociation annotation classes.
    Please see the Version 1 and Version 2 "fbc" specifications for more
    details.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfGeneProducts, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfGeneProducts, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ListOfGeneProducts self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ListOfGeneProducts
        __init__(ListOfGeneProducts self, unsigned int level, unsigned int version) -> ListOfGeneProducts
        __init__(ListOfGeneProducts self, unsigned int level) -> ListOfGeneProducts
        __init__(ListOfGeneProducts self) -> ListOfGeneProducts
        __init__(ListOfGeneProducts self, FbcPkgNamespaces fbcns) -> ListOfGeneProducts


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfGeneProducts(long level      =
        FbcExtension.getDefaultLevel(), long version    =
        FbcExtension.getDefaultVersion(), long pkgVersion =
        FbcExtension.getDefaultPackageVersion())

        Creates a new GeneProduct with the given SBML Level, Version, and
        "fbc"package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        ListOfGeneProducts.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this ListOfGeneProducts.

        Parameter 'pkgVersion' is a long integer, the SBML Fbc Version to
        assign to this ListOfGeneProducts.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfGeneProducts(FbcPkgNamespaces fbcns)

        Creates a new ListOfGeneProducts with the given FbcPkgNamespaces
        object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'fbcns' is the FbcPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_ListOfGeneProducts(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ListOfGeneProducts self) -> ListOfGeneProducts


        Creates and returns a deep copy of this ListOfGeneProducts object.

        Returns a (deep) copy of this ListOfGeneProducts object.

        """
        return _libsbml.ListOfGeneProducts_clone(self)


    def get(self, *args):
        """
        get(ListOfGeneProducts self, unsigned int n) -> GeneProduct
        get(ListOfGeneProducts self, unsigned int n) -> GeneProduct
        get(ListOfGeneProducts self, string sid) -> GeneProduct
        get(ListOfGeneProducts self, string sid) -> GeneProduct


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a GeneProduct from the ListOfGeneProducts.

        Parameter 'n' is the index number of the GeneProduct to get.

        Returns the nth GeneProduct in this ListOfGeneProducts. If the index
        'n' is invalid, 'None' is returned.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a GeneProduct from the ListOfGeneProducts based on its identifier.

        Parameter 'sid' is a string representing the identifier of the
        GeneProduct to get.

        Returns GeneProduct in this ListOfGeneProducts with the given id or
        'None' if no such GeneProduct exists.

        See also get(), size().

        """
        return _libsbml.ListOfGeneProducts_get(self, *args)


    def addGeneProduct(self, gp):
        """
        addGeneProduct(ListOfGeneProducts self, GeneProduct gp) -> int


        Adds a copy the given GeneProduct to this ListOfGeneProducts.

        Parameter 'gp' is the GeneProduct object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.ListOfGeneProducts_addGeneProduct(self, gp)


    def getNumGeneProducts(self):
        """
        getNumGeneProducts(ListOfGeneProducts self) -> unsigned int


        Get the number of GeneProduct objects in this ListOfGeneProducts.

        Returns the number of GeneProduct objects in this ListOfGeneProducts.

        """
        return _libsbml.ListOfGeneProducts_getNumGeneProducts(self)


    def createGeneProduct(self):
        """
        createGeneProduct(ListOfGeneProducts self) -> GeneProduct


        Creates a new GeneProduct object, adds it to the ListOfGeneProducts
        and returns the GeneProduct object created.

        Returns a new GeneProduct object instance.

        See also addGeneProduct().

        """
        return _libsbml.ListOfGeneProducts_createGeneProduct(self)


    def remove(self, *args):
        """
        remove(ListOfGeneProducts self, unsigned int n) -> GeneProduct
        remove(ListOfGeneProducts self, string sid) -> GeneProduct


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth GeneProduct from this ListOfGeneProducts and returns a
        pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the GeneProduct to remove.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes the GeneProduct from this ListOfGeneProducts with the given
        identifier and returns a pointer to it.

        The caller owns the returned item and is responsible for deleting it.
        If none of the items in this list have the identifier 'sid', then
        'None' is returned.

        Parameter 'sid' is the identifier of the GeneProduct to remove.

        Returns the GeneProduct removed. As mentioned above, the caller owns
        the returned item.

        """
        return _libsbml.ListOfGeneProducts_remove(self, *args)


    def getElementName(self):
        """
        getElementName(ListOfGeneProducts self) -> string


        Returns the XML element name of this object.

        For ListOfGeneProducts, the XML element name is always
        ''listOfGeneProducts'.'

        Returns the name of this element, i.e. ''listOfGeneProducts'.'

        """
        return _libsbml.ListOfGeneProducts_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(ListOfGeneProducts self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_LIST_OF (default).

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfGeneProducts_getTypeCode(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfGeneProducts self) -> int


        Returns the libSBML type code for the objects contained in this
        ListOf.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for the objects contained in this ListOf
        instance: SBML_FBC_GENEPRODUCT (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfGeneProducts_getItemTypeCode(self)

    __swig_destroy__ = _libsbml.delete_ListOfGeneProducts
    __del__ = lambda self: None
ListOfGeneProducts_swigregister = _libsbml.ListOfGeneProducts_swigregister
ListOfGeneProducts_swigregister(ListOfGeneProducts)

class GeneProductRef(FbcAssociation):
    """

    [SBML 'fbc' package]  Reference to a gene product of a reaction

    GeneProductRef encodes a references to a GeneProduct object declared
    in a ListOfGeneProducts attached to the enclosing Model object.
    GeneProductRef is derived from the FbcAssociation class.

    GeneProductRef objects are used to construct the content of
    GeneProductAssociation objects.  As described more fully in the
    documentation of the latter, a GeneProductAssociation is a container
    that may contain either (i) a single GeneProductRef or (ii) a logical
    expression built up with FbcAnd and FbcOr and ultimately containing
    two or more GeneProductRef objects.

    Note: This class of objects was introduced in Version 2 of the SBML
    Level 3 Flux Balance Constraints ("fbc") specification.  In Version
    1 of "fbc", the information encoded by this class can be stored
    instead using the Association and GeneAssociation annotation classes.
    Please see the Version 1 and Version 2 "fbc" specifications for more
    details.

    """

    __swig_setmethods__ = {}
    for _s in [FbcAssociation]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GeneProductRef, name, value)
    __swig_getmethods__ = {}
    for _s in [FbcAssociation]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, GeneProductRef, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(GeneProductRef self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> GeneProductRef
        __init__(GeneProductRef self, unsigned int level, unsigned int version) -> GeneProductRef
        __init__(GeneProductRef self, unsigned int level) -> GeneProductRef
        __init__(GeneProductRef self) -> GeneProductRef
        __init__(GeneProductRef self, FbcPkgNamespaces fbcns) -> GeneProductRef
        __init__(GeneProductRef self, GeneProductRef orig) -> GeneProductRef


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            GeneProductRef(long level      =
        FbcExtension.getDefaultLevel(), long version    =
        FbcExtension.getDefaultVersion(), long pkgVersion =
        FbcExtension.getDefaultPackageVersion())

        Creates a new GeneProductRef with the given SBML Level, Version, and
        "fbc"package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        GeneProductRef.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this GeneProductRef.

        Parameter 'pkgVersion' is a long integer, the SBML Fbc Version to
        assign to this GeneProductRef.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            GeneProductRef(GeneProductRef orig)

        Copy constructor for GeneProductRef.

        Parameter 'orig' is the GeneProductRef instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            GeneProductRef(FbcPkgNamespaces fbcns)

        Creates a new GeneProductRef with the given FbcPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'fbcns' is the FbcPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_GeneProductRef(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(GeneProductRef self) -> GeneProductRef


        Creates and returns a deep copy of this GeneProductRef object.

        Returns a (deep) copy of this GeneProductRef object.

        """
        return _libsbml.GeneProductRef_clone(self)

    __swig_destroy__ = _libsbml.delete_GeneProductRef
    __del__ = lambda self: None

    def getId(self):
        """
        getId(GeneProductRef self) -> string


        Returns the value of the 'id' attribute of this GeneProductRef.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is now recommended to use the
        getIdAttribute() function instead.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns the id of this GeneProductRef.

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.GeneProductRef_getId(self)


    def getGeneProduct(self):
        """
        getGeneProduct(GeneProductRef self) -> string


        Returns the value of the 'geneProduct' attribute of this
        GeneProductRef.

        Returns the value of the 'geneProduct' attribute of this
        GeneProductRef as a string.

        """
        return _libsbml.GeneProductRef_getGeneProduct(self)


    def toInfix(self, usingId=False):
        """
        toInfix(GeneProductRef self, bool usingId=False) -> string
        toInfix(GeneProductRef self) -> string


        Converts this FbcAssociation object into an infix string
        representation.

        Returns the association as infix string.

        """
        return _libsbml.GeneProductRef_toInfix(self, usingId)


    def getName(self):
        """
        getName(GeneProductRef self) -> string


        Returns the value of the 'name' attribute of this GeneProductRef
        object.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns the name of this SBML object, or the empty string if not set
        or unsettable.

        See also getIdAttribute(), isSetName(), setName(), unsetName().

        """
        return _libsbml.GeneProductRef_getName(self)


    def isSetId(self):
        """
        isSetId(GeneProductRef self) -> bool


        Predicate returning 'True' if this GeneProductRef's 'id' attribute is
        set.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns 'True' if the 'id' attribute of this SBML object is set,
        'False' otherwise.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is recommended that callers use
        isSetIdAttribute() instead.

        See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(),
        isSetIdAttribute().

        """
        return _libsbml.GeneProductRef_isSetId(self)


    def isSetGeneProduct(self):
        """
        isSetGeneProduct(GeneProductRef self) -> bool


        Predicate returning 'True' if this GeneProductRef's 'geneProduct'
        attribute is set.

        Returns 'True' if this GeneProductRef's 'geneProduct' attribute has
        been set, otherwise 'False' is returned.

        """
        return _libsbml.GeneProductRef_isSetGeneProduct(self)


    def isSetName(self):
        """
        isSetName(GeneProductRef self) -> bool


        Predicate returning 'True' if this GeneProductRef's 'name' attribute
        is set.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns 'True' if the 'name' attribute of this SBML object is set,
        'False' otherwise.

        See also getName(), setName(), unsetName().

        """
        return _libsbml.GeneProductRef_isSetName(self)


    def setId(self, sid):
        """
        setId(GeneProductRef self, string sid) -> int


        Sets the value of the 'id' attribute of this GeneProductRef.

        The string 'sid' is copied.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Parameter 'sid' is the string to use as the identifier of this object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.GeneProductRef_setId(self, sid)


    def setGeneProduct(self, geneProduct):
        """
        setGeneProduct(GeneProductRef self, string geneProduct) -> int


        Sets the value of the 'geneProduct' attribute of this GeneProductRef.

        Parameter 'geneProduct' is the value of the 'geneProduct' attribute to
        be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.GeneProductRef_setGeneProduct(self, geneProduct)


    def setName(self, name):
        """
        setName(GeneProductRef self, string name) -> int


        Sets the value of the 'name' attribute of this GeneProductRef.

        The string in 'name' is copied.

        Parameter 'name' is the new name for the SBML object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.GeneProductRef_setName(self, name)


    def unsetId(self):
        """
        unsetId(GeneProductRef self) -> int


        Unsets the value of the 'id' attribute of this GeneProductRef.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.GeneProductRef_unsetId(self)


    def unsetGeneProduct(self):
        """
        unsetGeneProduct(GeneProductRef self) -> int


        Unsets the value of the 'geneProduct' attribute of this
        GeneProductRef.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.GeneProductRef_unsetGeneProduct(self)


    def unsetName(self):
        """
        unsetName(GeneProductRef self) -> int


        Unsets the value of the 'name' attribute of this GeneProductRef.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getName(), setName(), isSetName().

        """
        return _libsbml.GeneProductRef_unsetName(self)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(GeneProductRef self, string oldid, string newid)


        Replaces all uses of a given 'SIdRef' type attribute value with
        another value.

        In SBML, object identifiers are of a data type called SId. In SBML
        Level 3, an explicit data type called SIdRef was introduced for
        attribute values that refer to SId values; in previous Levels of SBML,
        this data type did not exist and attributes were simply described to
        as 'referring to an identifier', but the effective data type was the
        same as SIdRef in Level 3.  These and other methods of libSBML refer
        to the type SIdRef for all Levels of SBML, even if the corresponding
        SBML specification did not explicitly name the data type.

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas in MathML content, comparing the referenced
        identifiers to the value of 'oldid'.  If any matches are found, the
        matching values are replaced with 'newid'.  The method does not
        descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.GeneProductRef_renameSIdRefs(self, oldid, newid)


    def getElementName(self):
        """
        getElementName(GeneProductRef self) -> string


        Returns the XML element name of this object.

        For GeneProductRef, the XML element name is always ''geneProductRef'.'

        Returns the name of this element, i.e. ''geneProductRef'.'

        """
        return _libsbml.GeneProductRef_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(GeneProductRef self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_FBC_GENEPRODUCTREF
        (default).

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.GeneProductRef_getTypeCode(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(GeneProductRef self) -> bool


        Predicate returning 'True' if all the required attributes for this
        GeneProductRef object have been set.

        Note: The required attributes for a GeneProductRef object are:

        * 'geneProduct'

        Returns a boolean value indicating whether all the required attributes
        for this object have been defined.

        """
        return _libsbml.GeneProductRef_hasRequiredAttributes(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(GeneProductRef self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.GeneProductRef_enablePackageInternal(self, pkgURI, pkgPrefix, flag)

GeneProductRef_swigregister = _libsbml.GeneProductRef_swigregister
GeneProductRef_swigregister(GeneProductRef)

class FbcAnd(FbcAssociation):
    """

    [SBML 'fbc' package]  An "and" relationship for gene products

    FbcAnd class is used in Version 2 of the SBML Level 3 Flux Balance
    Constraints ("fbc") package to represent an 'and' relationship
    between two or more child FbcAssociation objects.  In other words, it
    indicates that all of the child objects are included.  Note that since
    the FbcAssociation class is the parent class of GeneProductRef, FbcAnd
    and FbcOr, a given FbcAnd can potentially include nested 'and'/'or'
    combinations of gene products.

    Note: This class of objects was introduced in Version 2 of the SBML
    Level 3 Flux Balance Constraints ("fbc") specification.  In Version
    1 of "fbc", the information encoded by this class can be stored
    instead using the Association and GeneAssociation annotation classes.
    Please see the Version 1 and Version 2 "fbc" specifications for more
    details.

    See also FbcAssociation, FbcOr, GeneProductRef.

    """

    __swig_setmethods__ = {}
    for _s in [FbcAssociation]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FbcAnd, name, value)
    __swig_getmethods__ = {}
    for _s in [FbcAssociation]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, FbcAnd, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(FbcAnd self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> FbcAnd
        __init__(FbcAnd self, unsigned int level, unsigned int version) -> FbcAnd
        __init__(FbcAnd self, unsigned int level) -> FbcAnd
        __init__(FbcAnd self) -> FbcAnd
        __init__(FbcAnd self, FbcPkgNamespaces fbcns) -> FbcAnd
        __init__(FbcAnd self, FbcAnd orig) -> FbcAnd


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            FbcAnd(long level      = FbcExtension.getDefaultLevel(), long
        version    = FbcExtension.getDefaultVersion(), long pkgVersion =
        FbcExtension.getDefaultPackageVersion())

        Creates a new FbcAnd with the given SBML Level, Version, and
        "fbc"package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        FbcAnd.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this FbcAnd.

        Parameter 'pkgVersion' is a long integer, the SBML Fbc Version to
        assign to this FbcAnd.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            FbcAnd(FbcAnd orig)

        Copy constructor for FbcAnd.

        Parameter 'orig' is the FbcAnd instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            FbcAnd(FbcPkgNamespaces fbcns)

        Creates a new FbcAnd with the given FbcPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'fbcns' is the FbcPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_FbcAnd(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(FbcAnd self) -> FbcAnd


        Creates and returns a deep copy of this FbcAnd object.

        Returns a (deep) copy of this FbcAnd object.

        """
        return _libsbml.FbcAnd_clone(self)

    __swig_destroy__ = _libsbml.delete_FbcAnd
    __del__ = lambda self: None

    def getListOfAssociations(self, *args):
        """
        getListOfAssociations(FbcAnd self) -> ListOfFbcAssociations
        getListOfAssociations(FbcAnd self) -> ListOfFbcAssociations


        Returns the ListOfFbcAssociations in this FbcAnd object.

        Returns the ListOfFbcAssociations child of this FbcAnd.

        """
        return _libsbml.FbcAnd_getListOfAssociations(self, *args)


    def getAssociation(self, *args):
        """
        getAssociation(FbcAnd self, unsigned int n) -> FbcAssociation
        getAssociation(FbcAnd self, unsigned int n) -> FbcAssociation
        getAssociation(FbcAnd self, string sid) -> FbcAssociation
        getAssociation(FbcAnd self, string sid) -> FbcAssociation


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getAssociation(long n)

        Get the nth object from the ListOfFbcAssociations.

        Parameter 'n' is the index number of the FbcAssociation to get.

        Returns the nth FbcAssociation in the ListOfFbcAssociations within
        this FbcAnd. If the index 'n' is invalid, 'None' is returned.

        See also getNumAssociations().

        ______________________________________________________________________
        Method variant with the following signature:

            getAssociation(string sid)

        Get an FbcAssociation from the ListOfFbcAssociations based on its
        identifier.

        Parameter 'sid' is a string representing the identifier of the
        FbcAssociation to get.

        Returns the FbcAssociation in the ListOfFbcAssociations with the given
        id or 'None' if no such FbcAssociation exists.

        See also getAssociation().

        See also getNumAssociations().

        """
        return _libsbml.FbcAnd_getAssociation(self, *args)


    def addAssociation(self, fa):
        """
        addAssociation(FbcAnd self, FbcAssociation fa) -> int


        Adds a copy the given FbcAssociation to this FbcAnd.

        Parameter 'fa' is the FbcAssociation object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_PKG_VERSION_MISMATCH

        * LIBSBML_NAMESPACES_MISMATCH

        """
        return _libsbml.FbcAnd_addAssociation(self, fa)


    def getNumAssociations(self):
        """
        getNumAssociations(FbcAnd self) -> unsigned int


        Get the number of FbcAssociation objects in this FbcAnd.

        Returns the number of FbcAssociation objects in this FbcAnd.

        """
        return _libsbml.FbcAnd_getNumAssociations(self)


    def toInfix(self, usingId=False):
        """
        toInfix(FbcAnd self, bool usingId=False) -> string
        toInfix(FbcAnd self) -> string


        Converts this FbcAssociation object into an infix string
        representation.

        Returns the association as infix string.

        """
        return _libsbml.FbcAnd_toInfix(self, usingId)


    def createAnd(self):
        """
        createAnd(FbcAnd self) -> FbcAnd


        Creates a new FbcAnd object, adds it to this FbcAnd's
        ListOfFbcAssociations and returns the FbcAnd object created.

        Returns a new FbcAnd object instance.

        See also addAssociation().

        """
        return _libsbml.FbcAnd_createAnd(self)


    def createOr(self):
        """
        createOr(FbcAnd self) -> FbcOr


        Creates a new FbcOr object, adds it to this FbcAnd's
        ListOfFbcAssociations and returns the FbcOr object created.

        Returns a new FbcOr object instance.

        See also addAssociation().

        """
        return _libsbml.FbcAnd_createOr(self)


    def createGeneProductRef(self):
        """
        createGeneProductRef(FbcAnd self) -> GeneProductRef


        Creates a new GeneProductRef object, adds it to this FbcAnd's
        ListOfFbcAssociations and returns the GeneProductRef object created.

        Returns a new GeneProductRef object instance.

        See also addAssociation().

        """
        return _libsbml.FbcAnd_createGeneProductRef(self)


    def removeAssociation(self, *args):
        """
        removeAssociation(FbcAnd self, unsigned int n) -> FbcAssociation
        removeAssociation(FbcAnd self, string sid) -> FbcAssociation


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeAssociation(long n)

        Removes the nth FbcAssociation from the ListOfFbcAssociations within
        this  FbcAnd and returns a pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the FbcAssociation to remove.

        See also getNumAssociations().

        ______________________________________________________________________
        Method variant with the following signature:

            removeAssociation(string sid)

        Removes the FbcAssociation with the given identifier from the
        ListOfFbcAssociations within this FbcAnd and returns a pointer to it.

        The caller owns the returned item and is responsible for deleting it.
        If none of the items in this list have the identifier 'sid', then
        'None' is returned.

        Parameter 'sid' is the identifier of the FbcAssociation to remove.

        Returns the FbcAssociation removed. As mentioned above, the caller
        owns the returned item.

        """
        return _libsbml.FbcAnd_removeAssociation(self, *args)


    def getElementName(self):
        """
        getElementName(FbcAnd self) -> string


        Returns the XML element name of this object.

        For FbcAnd, the XML element name is always ''fbcAnd'.'

        Returns the name of this element, i.e. ''fbcAnd'.'

        """
        return _libsbml.FbcAnd_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(FbcAnd self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_FBC_AND (default).

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.FbcAnd_getTypeCode(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(FbcAnd self) -> bool


        Predicate returning 'True' if all the required attributes for this
        FbcAnd object have been set.  Will always return 'True,' since FbcOr
        has no required attributes.

        Returns a boolean value indicating whether all the required attributes
        for this object have been defined.

        """
        return _libsbml.FbcAnd_hasRequiredAttributes(self)


    def hasRequiredElements(self):
        """
        hasRequiredElements(FbcAnd self) -> bool


        Predicate returning 'True' if all the required elements for this
        FbcAnd object have been set.

        Note: An FbcAnd object must have at least two FbcAssociation children.

        Returns a boolean value indicating whether all the required elements
        for this object have been defined.

        """
        return _libsbml.FbcAnd_hasRequiredElements(self)


    def connectToChild(self):
        """
        connectToChild(FbcAnd self)


        Internal implementation method.

        """
        return _libsbml.FbcAnd_connectToChild(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(FbcAnd self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.FbcAnd_enablePackageInternal(self, pkgURI, pkgPrefix, flag)

FbcAnd_swigregister = _libsbml.FbcAnd_swigregister
FbcAnd_swigregister(FbcAnd)

class FbcOr(FbcAssociation):
    """

    [SBML 'fbc' package]  An "or" relationship for gene products

    FbcOr class is used in Version 2 of the SBML Level 3 Flux Balance
    Constraints ("fbc") package to represent an 'or' relationship
    between two or more child FbcAssociation objects.  In other words, it
    indicates that only one of the child objects are included.  Note that
    since the FbcAssociation class is the parent class of GeneProductRef,
    FbcAnd, and FbcOr, a given FbcOr can potentially include nested
    'and'/'or' combinations of gene products.

    Note: This class of objects was introduced in Version 2 of the SBML
    Level 3 Flux Balance Constraints ("fbc") specification.  In Version
    1 of "fbc", the information encoded by this class can be stored
    instead using the Association and GeneAssociation annotation classes.
    Please see the Version 1 and Version 2 "fbc" specifications for more
    details.

    See also FbcAssociation, FbcAnd, GeneProductRef.

    """

    __swig_setmethods__ = {}
    for _s in [FbcAssociation]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FbcOr, name, value)
    __swig_getmethods__ = {}
    for _s in [FbcAssociation]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, FbcOr, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(FbcOr self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> FbcOr
        __init__(FbcOr self, unsigned int level, unsigned int version) -> FbcOr
        __init__(FbcOr self, unsigned int level) -> FbcOr
        __init__(FbcOr self) -> FbcOr
        __init__(FbcOr self, FbcPkgNamespaces fbcns) -> FbcOr
        __init__(FbcOr self, FbcOr orig) -> FbcOr


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            FbcOr(long level      = FbcExtension.getDefaultLevel(), long
        version    = FbcExtension.getDefaultVersion(), long pkgVersion =
        FbcExtension.getDefaultPackageVersion())

        Creates a new FbcOr with the given SBML Level, Version, and
        "fbc"package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        FbcOr.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this FbcOr.

        Parameter 'pkgVersion' is a long integer, the SBML Fbc Version to
        assign to this FbcOr.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            FbcOr(FbcOr orig)

        Copy constructor for FbcOr.

        Parameter 'orig' is the FbcOr instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            FbcOr(FbcPkgNamespaces fbcns)

        Creates a new FbcOr with the given FbcPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'fbcns' is the FbcPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_FbcOr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(FbcOr self) -> FbcOr


        Creates and returns a deep copy of this FbcOr object.

        Returns a (deep) copy of this FbcOr object.

        """
        return _libsbml.FbcOr_clone(self)

    __swig_destroy__ = _libsbml.delete_FbcOr
    __del__ = lambda self: None

    def getListOfAssociations(self, *args):
        """
        getListOfAssociations(FbcOr self) -> ListOfFbcAssociations
        getListOfAssociations(FbcOr self) -> ListOfFbcAssociations


        Returns the ListOfFbcAssociations in this FbcOr object.

        Returns the ListOfFbcAssociations child of this FbcOr.

        """
        return _libsbml.FbcOr_getListOfAssociations(self, *args)


    def getAssociation(self, *args):
        """
        getAssociation(FbcOr self, unsigned int n) -> FbcAssociation
        getAssociation(FbcOr self, unsigned int n) -> FbcAssociation
        getAssociation(FbcOr self, string sid) -> FbcAssociation
        getAssociation(FbcOr self, string sid) -> FbcAssociation


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getAssociation(long n)

        Get a Association from the ListOfFbcAssociations.

        Parameter 'n' is the index number of the Association to get.

        Returns the nth Association in the ListOfFbcAssociations within this
        FbcOr. If the index 'n' is invalid, 'None' is returned.

        See also getNumAssociations().

        ______________________________________________________________________
        Method variant with the following signature:

            getAssociation(string sid)

        Get a Association from the ListOfFbcAssociations based on its
        identifier.

        Parameter 'sid' is a string representing the identifier of the
        Association to get.

        Returns the Association in the ListOfFbcAssociations with the given id
        or 'None' if no such Association exists.

        See also getAssociation().

        See also getNumAssociations().

        """
        return _libsbml.FbcOr_getAssociation(self, *args)


    def addAssociation(self, fa):
        """
        addAssociation(FbcOr self, FbcAssociation fa) -> int


        Adds a copy the given FbcAssociation to this FbcOr.

        Parameter 'fa' is the FbcAssociation object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_PKG_VERSION_MISMATCH

        * LIBSBML_NAMESPACES_MISMATCH

        """
        return _libsbml.FbcOr_addAssociation(self, fa)


    def getNumAssociations(self):
        """
        getNumAssociations(FbcOr self) -> unsigned int


        Get the number of FbcAssociation objects in this FbcOr.

        Returns the number of FbcAssociation objects in this FbcOr.

        """
        return _libsbml.FbcOr_getNumAssociations(self)


    def toInfix(self, usingId=False):
        """
        toInfix(FbcOr self, bool usingId=False) -> string
        toInfix(FbcOr self) -> string


        Converts this FbcAssociation object into an infix string
        representation.

        Returns the association as infix string.

        """
        return _libsbml.FbcOr_toInfix(self, usingId)


    def createAnd(self):
        """
        createAnd(FbcOr self) -> FbcAnd


        Creates a new FbcAnd object, adds it to this FbcOr's
        ListOfFbcAssociations and returns the FbcAnd object created.

        Returns a new FbcAnd object instance.

        See also addAssociation().

        """
        return _libsbml.FbcOr_createAnd(self)


    def createOr(self):
        """
        createOr(FbcOr self) -> FbcOr


        Creates a new FbcOr object, adds it to this FbcOr's
        ListOfFbcAssociations and returns the FbcOr object created.

        Returns a new FbcOr object instance.

        See also addAssociation().

        """
        return _libsbml.FbcOr_createOr(self)


    def createGeneProductRef(self):
        """
        createGeneProductRef(FbcOr self) -> GeneProductRef


        Creates a new GeneProductRef object, adds it to this FbcOr's
        ListOfFbcAssociations and returns the GeneProductRef object created.

        Returns a new GeneProductRef object instance.

        See also addAssociation().

        """
        return _libsbml.FbcOr_createGeneProductRef(self)


    def removeAssociation(self, *args):
        """
        removeAssociation(FbcOr self, unsigned int n) -> FbcAssociation
        removeAssociation(FbcOr self, string sid) -> FbcAssociation


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeAssociation(long n)

        Removes the nth Association from the ListOfFbcAssociations within this
        FbcOr and returns a pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the Association to remove.

        See also getNumAssociations().

        ______________________________________________________________________
        Method variant with the following signature:

            removeAssociation(string sid)

        Removes the Association with the given identifier from the
        ListOfFbcAssociations within this FbcOr and returns a pointer to it.

        The caller owns the returned item and is responsible for deleting it.
        If none of the items in this list have the identifier 'sid', then
        'None' is returned.

        Parameter 'sid' is the identifier of the Association to remove.

        Returns the Association removed. As mentioned above, the caller owns
        the returned item.

        """
        return _libsbml.FbcOr_removeAssociation(self, *args)


    def getElementName(self):
        """
        getElementName(FbcOr self) -> string


        Returns the XML element name of this object.

        For FbcOr, the XML element name is always ''fbcOr'.'

        Returns the name of this element, i.e. ''fbcOr'.'

        """
        return _libsbml.FbcOr_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(FbcOr self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_FBC_OR (default).

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.FbcOr_getTypeCode(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(FbcOr self) -> bool


        Predicate returning 'True' if all the required attributes for this
        FbcOr object have been set.  Will always return 'True,' since FbcOr
        has no required attributes.

        Returns a boolean value indicating whether all the required attributes
        for this object have been defined.

        """
        return _libsbml.FbcOr_hasRequiredAttributes(self)


    def hasRequiredElements(self):
        """
        hasRequiredElements(FbcOr self) -> bool


        Predicate returning 'True' if all the required elements for this FbcOr
        object have been set.

        Note: An FbcOr object must have at least two FbcAssociation children.

        Returns a boolean value indicating whether all the required elements
        for this object have been defined.

        """
        return _libsbml.FbcOr_hasRequiredElements(self)


    def connectToChild(self):
        """
        connectToChild(FbcOr self)


        Internal implementation method.

        """
        return _libsbml.FbcOr_connectToChild(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(FbcOr self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.FbcOr_enablePackageInternal(self, pkgURI, pkgPrefix, flag)

FbcOr_swigregister = _libsbml.FbcOr_swigregister
FbcOr_swigregister(FbcOr)

class GroupsPkgNamespaces(SBMLNamespaces):
    """

    Set of SBML Level + Version + namespace triples.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    SBMLExtensionNamespaces is a template class.  It is extended from
    SBMLNamespaces and is meant to be used by package extensions to store
    the SBML Level, Version within a Level, and package version of the
    SBML Level 3 package implemented by a libSBML package extension.

    Basic principles of SBML package extensions in libSBML
    ======================================================================

    SBML Level 3's package structure permits modular extensions to the
    core SBML format.  In libSBML, support for SBML Level 3 packages is
    provided through optional package extensions that can be plugged into
    libSBML at the time it is built/compiled.  Users of libSBML can thus
    choose which extensions are enabled in their software applications.

    LibSBML defines a number of classes that developers of package
    extensions can use to implement support for an SBML Level 3 package.
    These classes make it easier to extend libSBML objects with new
    attributes and/or subobjects as needed by a particular Level 3
    package. Three overall categories of classes make up libSBML's
    facilities for implementing package extensions.  There are (1) classes
    that serve as base classes meant to be subclassed, (2) template
    classes meant to be instantiated rather than subclassed, and (3)
    support classes that provide utility features. A given package
    implementation for libSBML will take the form of code using these and
    other libSBML classes, placed in a subdirectory of src/sbml/packages/.

    The basic libSBML distribution includes a number of package extensions
    implementing support for officially-endorsed SBML Level 3 packages;
    among these are Flux Balance Constraints ('fbc'), Hierarchical Model
    Composition ('comp'), Layout ('layout'), and Qualitative Models
    ('qual').  They can serve as working examples for developers working
    to implement other packages.

    Extensions in libSBML can currently only be implemented in C++ or C;
    there is no mechanism to implement them first in languages such as
    Java or Python.  However, once implemented in C++ or C, language
    interfaces can be generated semi-automatically using the framework in
    place in libSBML.  (The approach is based on using SWIG and facilities
    in libSBML's build system.)

    """

    __swig_setmethods__ = {}
    for _s in [SBMLNamespaces]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GroupsPkgNamespaces, name, value)
    __swig_getmethods__ = {}
    for _s in [SBMLNamespaces]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, GroupsPkgNamespaces, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_GroupsPkgNamespaces
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(SBMLExtensionNamespaces<(GroupsExtension)> self, unsigned int level, unsigned int version, unsigned int pkgVersion, string prefix) -> GroupsPkgNamespaces
        __init__(SBMLExtensionNamespaces<(GroupsExtension)> self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> GroupsPkgNamespaces
        __init__(SBMLExtensionNamespaces<(GroupsExtension)> self, unsigned int level, unsigned int version) -> GroupsPkgNamespaces
        __init__(SBMLExtensionNamespaces<(GroupsExtension)> self, unsigned int level) -> GroupsPkgNamespaces
        __init__(SBMLExtensionNamespaces<(GroupsExtension)> self) -> GroupsPkgNamespaces
        __init__(SBMLExtensionNamespaces<(GroupsExtension)> self, GroupsPkgNamespaces orig) -> GroupsPkgNamespaces


        Set of SBML Level + Version + namespace triples.

        This class of objects is defined by libSBML only and has no direct
        equivalent in terms of SBML components.  This class is not prescribed
        by the SBML specifications, although it is used to implement features
        defined in SBML.

        SBMLExtensionNamespaces is a template class.  It is extended from
        SBMLNamespaces and is meant to be used by package extensions to store
        the SBML Level, Version within a Level, and package version of the
        SBML Level 3 package implemented by a libSBML package extension.

        Basic principles of SBML package extensions in libSBML
        ======================================================================

        SBML Level 3's package structure permits modular extensions to the
        core SBML format.  In libSBML, support for SBML Level 3 packages is
        provided through optional package extensions that can be plugged into
        libSBML at the time it is built/compiled.  Users of libSBML can thus
        choose which extensions are enabled in their software applications.

        LibSBML defines a number of classes that developers of package
        extensions can use to implement support for an SBML Level 3 package.
        These classes make it easier to extend libSBML objects with new
        attributes and/or subobjects as needed by a particular Level 3
        package. Three overall categories of classes make up libSBML's
        facilities for implementing package extensions.  There are (1) classes
        that serve as base classes meant to be subclassed, (2) template
        classes meant to be instantiated rather than subclassed, and (3)
        support classes that provide utility features. A given package
        implementation for libSBML will take the form of code using these and
        other libSBML classes, placed in a subdirectory of src/sbml/packages/.

        The basic libSBML distribution includes a number of package extensions
        implementing support for officially-endorsed SBML Level 3 packages;
        among these are Flux Balance Constraints ('fbc'), Hierarchical Model
        Composition ('comp'), Layout ('layout'), and Qualitative Models
        ('qual').  They can serve as working examples for developers working
        to implement other packages.

        Extensions in libSBML can currently only be implemented in C++ or C;
        there is no mechanism to implement them first in languages such as
        Java or Python.  However, once implemented in C++ or C, language
        interfaces can be generated semi-automatically using the framework in
        place in libSBML.  (The approach is based on using SWIG and facilities
        in libSBML's build system.)

        """
        this = _libsbml.new_GroupsPkgNamespaces(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(GroupsPkgNamespaces self) -> ISBMLExtensionNamespaces


        Creates and returns a deep copy of this SBMLNamespaces object.

        Returns the (deep) copy of this SBMLNamespaces object.

        """
        return _libsbml.GroupsPkgNamespaces_clone(self)


    def getURI(self):
        """
        getURI(GroupsPkgNamespaces self) -> string


        Returns a string representing the SBML XML namespace of this object.

        Returns a string representing the SBML namespace that reflects the
        SBML Level and Version of this object.

        """
        return _libsbml.GroupsPkgNamespaces_getURI(self)


    def getPackageVersion(self):
        """getPackageVersion(GroupsPkgNamespaces self) -> unsigned int"""
        return _libsbml.GroupsPkgNamespaces_getPackageVersion(self)


    def getPackageName(self):
        """
        getPackageName(GroupsPkgNamespaces self) -> string


        Returns the name of the main package for this namespace.

        Returns the name of the main package for this namespace. 'core' will
        be returned if this namespace is defined in the SBML  core.

        """
        return _libsbml.GroupsPkgNamespaces_getPackageName(self)

GroupsPkgNamespaces_swigregister = _libsbml.GroupsPkgNamespaces_swigregister
GroupsPkgNamespaces_swigregister(GroupsPkgNamespaces)

class GroupsExtension(SBMLExtension):
    """

    [SBML 'groups' package]  Base extension class for the package.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    This is the Groups package extension of the SBMLExtension class that
    is used to facilitate libSBML plug-ins in the implementation of an
    SBMLLevel 3 package.

    """

    __swig_setmethods__ = {}
    for _s in [SBMLExtension]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GroupsExtension, name, value)
    __swig_getmethods__ = {}
    for _s in [SBMLExtension]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, GroupsExtension, name)
    __repr__ = _swig_repr

    def getPackageName():
        """
        getPackageName() -> string


        Returns the nickname of the SBML Level 3 package implemented by this
        libSBML extension.

        Returns the package nickname, as a string.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.GroupsExtension_getPackageName()

    getPackageName = staticmethod(getPackageName)

    def getDefaultLevel():
        """
        getDefaultLevel() -> unsigned int


        Returns the default SBML Level implemented by this libSBML extension.

        Returns the SBML Level, as a long integereger.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.GroupsExtension_getDefaultLevel()

    getDefaultLevel = staticmethod(getDefaultLevel)

    def getDefaultVersion():
        """
        getDefaultVersion() -> unsigned int


        Returns the default SBML Version implemented by this libSBML
        extension.

        Returns the Version within the default SBML Level, as a long
        integereger.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.GroupsExtension_getDefaultVersion()

    getDefaultVersion = staticmethod(getDefaultVersion)

    def getDefaultPackageVersion():
        """
        getDefaultPackageVersion() -> unsigned int


        Returns the default version of the SBML Level 3 package implemented by
        this libSBML extension.

        Returns the default version number of the SBML Level 3 package
        definition, as a long integereger.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.GroupsExtension_getDefaultPackageVersion()

    getDefaultPackageVersion = staticmethod(getDefaultPackageVersion)

    def getXmlnsL3V1V1():
        """
        getXmlnsL3V1V1() -> string


        Returns the XML namespace URI of the SBML Level 3 package implemented
        by this libSBML extension.

        Returns the XML namespace, as a string.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.GroupsExtension_getXmlnsL3V1V1()

    getXmlnsL3V1V1 = staticmethod(getXmlnsL3V1V1)

    def __init__(self, *args):
        """
        __init__(GroupsExtension self) -> GroupsExtension
        __init__(GroupsExtension self, GroupsExtension orig) -> GroupsExtension


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            GroupsExtension()

        Creates a new GroupsExtension instance.

        ______________________________________________________________________
        Method variant with the following signature:

            GroupsExtension(GroupsExtension orig)

        Copy constructor for GroupsExtension.

        Parameter 'orig' is the GroupsExtension instance to copy.

        """
        this = _libsbml.new_GroupsExtension(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(GroupsExtension self) -> GroupsExtension


        Creates and returns a deep copy of this GroupsExtension object.

        Returns a (deep) copy of this GroupsExtension object.

        """
        return _libsbml.GroupsExtension_clone(self)

    __swig_destroy__ = _libsbml.delete_GroupsExtension
    __del__ = lambda self: None

    def getName(self):
        """
        getName(GroupsExtension self) -> string


        Returns the name of this SBML Level 3 package ('groups').

        Returns a string representing the name of this package ('groups').

        """
        return _libsbml.GroupsExtension_getName(self)


    def getURI(self, sbmlLevel, sbmlVersion, pkgVersion):
        """
        getURI(GroupsExtension self, unsigned int sbmlLevel, unsigned int sbmlVersion, unsigned int pkgVersion) -> string


        Returns a string representing the SBML XML namespace of this SBML
        Level 3 package.

        Parameter 'sbmlLevel' is the level of SBML.

        Parameter 'sbmlVersion' is the version of SBML.

        Parameter 'pkgVersion' is the version of this package.

        Returns a string representing the name of this package ('groups').

        The namespace URI constructed by this method corresponds to the
        combination of the Level and Version of SBML, and the Version of the
        SBML Level 3 package. (At the time of this writing, the only SBML
        Level that supports packages is Level 3, so the value of 'sbmlLevel'
        is necessarily always 3.)

        """
        return _libsbml.GroupsExtension_getURI(self, sbmlLevel, sbmlVersion, pkgVersion)


    def getLevel(self, uri):
        """
        getLevel(GroupsExtension self, string uri) -> unsigned int


        Returns the SBML Level for the given URI of this package.

        Parameter 'uri' is the string of the URI that represents one of the
        versions of the 'groups' package.

        Returns the SBML Level for the given URI of this package, or '0' if
        the given URI is invalid, or for a different package.

        """
        return _libsbml.GroupsExtension_getLevel(self, uri)


    def getVersion(self, uri):
        """
        getVersion(GroupsExtension self, string uri) -> unsigned int


        Returns the Version within the SBML Level for the given URI of this
        package.

        Parameter 'uri' is the string of the URI that represents one of the
        versions of the 'groups' package.

        Returns the SBML Version within the SBML Level for the given URI of
        this package, or '0' if the given URI is invalid, or for a different
        package.

        """
        return _libsbml.GroupsExtension_getVersion(self, uri)


    def getPackageVersion(self, uri):
        """
        getPackageVersion(GroupsExtension self, string uri) -> unsigned int


        Returns the SBML Level 3 package version for the given URI of this
        package.

        Parameter 'uri' is the string of the URI that represents one of the
        versions of the 'groups' package.

        Returns the version of the SBML Level 3 package for the given URI of
        this package, or '0' if the given URI is invalid, or for a different
        package.

        """
        return _libsbml.GroupsExtension_getPackageVersion(self, uri)


    def getSBMLExtensionNamespaces(self, uri):
        """
        getSBMLExtensionNamespaces(GroupsExtension self, string uri) -> SBMLNamespaces


        Returns a GroupsPkgNamespaces object.

        Parameter 'uri' is the string of the URI that represents one of the
        versions of the 'groups' package.

        Returns GroupsPkgNamespaces object corresponding to the given URI of
        this package, or 'None' if the given URI is not defined in the
        'groups' package.

        """
        return _libsbml.GroupsExtension_getSBMLExtensionNamespaces(self, uri)


    def getStringFromTypeCode(self, typeCode):
        """
        getStringFromTypeCode(GroupsExtension self, int typeCode) -> char const *


        Takes a type code of the "groups" package and returns a string
        describing the code.

        Parameter 'typeCode' is a libSBML type code defined by the libSBML
        extension implementing support for the SBML Level 3 "groups"
        package.

        Returns a text string representing the type code given by 'typeCode'.
        If the type code is unrecognized for this implementation of the
        libSBML "groups" package, the string returned will be '(Unknown SBML
        Groups Type)'.

        """
        return _libsbml.GroupsExtension_getStringFromTypeCode(self, typeCode)


    def getErrorTable(self, index):
        """
        getErrorTable(GroupsExtension self, unsigned int index) -> packageErrorTableEntry


        Internal implementation method.

        """
        return _libsbml.GroupsExtension_getErrorTable(self, index)


    def getErrorTableIndex(self, errorId):
        """
        getErrorTableIndex(GroupsExtension self, unsigned int errorId) -> unsigned int


        Internal implementation method.

        """
        return _libsbml.GroupsExtension_getErrorTableIndex(self, errorId)


    def getErrorIdOffset(self):
        """
        getErrorIdOffset(GroupsExtension self) -> unsigned int


        Internal implementation method.

        """
        return _libsbml.GroupsExtension_getErrorIdOffset(self)


    def init():
        """
        init()


        Internal implementation method.

        """
        return _libsbml.GroupsExtension_init()

    init = staticmethod(init)
GroupsExtension_swigregister = _libsbml.GroupsExtension_swigregister
GroupsExtension_swigregister(GroupsExtension)

def GroupsExtension_getPackageName():
    """
    GroupsExtension_getPackageName() -> string


    Returns the nickname of the SBML Level 3 package implemented by this
    libSBML extension.

    Returns the package nickname, as a string.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.GroupsExtension_getPackageName()

def GroupsExtension_getDefaultLevel():
    """
    GroupsExtension_getDefaultLevel() -> unsigned int


    Returns the default SBML Level implemented by this libSBML extension.

    Returns the SBML Level, as a long integereger.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.GroupsExtension_getDefaultLevel()

def GroupsExtension_getDefaultVersion():
    """
    GroupsExtension_getDefaultVersion() -> unsigned int


    Returns the default SBML Version implemented by this libSBML
    extension.

    Returns the Version within the default SBML Level, as a long
    integereger.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.GroupsExtension_getDefaultVersion()

def GroupsExtension_getDefaultPackageVersion():
    """
    GroupsExtension_getDefaultPackageVersion() -> unsigned int


    Returns the default version of the SBML Level 3 package implemented by
    this libSBML extension.

    Returns the default version number of the SBML Level 3 package
    definition, as a long integereger.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.GroupsExtension_getDefaultPackageVersion()

def GroupsExtension_getXmlnsL3V1V1():
    """
    GroupsExtension_getXmlnsL3V1V1() -> string


    Returns the XML namespace URI of the SBML Level 3 package implemented
    by this libSBML extension.

    Returns the XML namespace, as a string.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.GroupsExtension_getXmlnsL3V1V1()

def GroupsExtension_init():
    """
    GroupsExtension_init()


    Internal implementation method.

    """
    return _libsbml.GroupsExtension_init()

SBML_GROUPS_MEMBER = _libsbml.SBML_GROUPS_MEMBER
SBML_GROUPS_GROUP = _libsbml.SBML_GROUPS_GROUP
GROUP_KIND_CLASSIFICATION = _libsbml.GROUP_KIND_CLASSIFICATION
GROUP_KIND_PARTONOMY = _libsbml.GROUP_KIND_PARTONOMY
GROUP_KIND_COLLECTION = _libsbml.GROUP_KIND_COLLECTION
GROUP_KIND_UNKNOWN = _libsbml.GROUP_KIND_UNKNOWN

def GroupKind_toString(gk):
    """
    GroupKind_toString(GroupKind_t gk) -> char const *


    Returns the string version of the provided enumeration value.

    Parameter 'gk' is the enumeration value to convert.

    Returns A string corresponding to the given type: 'classification',
    'partonomy', 'collection', or 'None' if the value is
    GROUP_KIND_UNKNOWN or another invalid enumeration value.

    Note: The string returned by this function is a pointer to a string
    literal defined in the libSBML library, and may not be modified or
    deleted.

    """
    return _libsbml.GroupKind_toString(gk)

def GroupKind_fromString(code):
    """
    GroupKind_fromString(char const * code) -> GroupKind_t


    Returns the enumeration value corresponding to the given string or
    GROUP_KIND_UNKNOWN if there is no such match.

    Parameter 'code' is the string to convert to an enumeration value.

    Returns the corresponding value, or GROUP_KIND_UNKNOWN if no match is
    found.

    Note: The matching is case-sensitive: 'classification' will return
    GROUP_KIND_CLASSIFICATION, but 'Classification' will return
    GROUP_KIND_UNKNOWN.

    """
    return _libsbml.GroupKind_fromString(code)

def GroupKind_isValid(gk):
    """
    GroupKind_isValid(GroupKind_t gk) -> int


    Predicate returning '1' (true) or '0' (false) depending on whether the
    given enumeration value is valid.

    Parameter 'gk' is the enumeration value to query.

    Returns '1' (true) if the value is GROUP_KIND_CLASSIFICATION,
    GROUP_KIND_PARTONOMY, or GROUP_KIND_COLLECTION; '0' (false) otherwise
    (including GROUP_KIND_UNKNOWN).

    """
    return _libsbml.GroupKind_isValid(gk)

def GroupKind_isValidString(code):
    """
    GroupKind_isValidString(char const * code) -> int


    Predicate returning '1' (true) or '0' (false) depending on whether the
    given string is a valid enumeration value.

    Parameter 'code' is the string to query.

    Returns '1' (true) if the string is 'classification', 'partonomy', or
    'collection'; '0' (false) otherwise.

    Note: The matching is case-sensitive: 'classification' will return '1'
    (true), but 'Classification' will return '0' (false).

    """
    return _libsbml.GroupKind_isValidString(code)
class GroupsModelPlugin(SBasePlugin):
    """

    [SBML 'groups' package]  Extension of Model.

    """

    __swig_setmethods__ = {}
    for _s in [SBasePlugin]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GroupsModelPlugin, name, value)
    __swig_getmethods__ = {}
    for _s in [SBasePlugin]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, GroupsModelPlugin, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(GroupsModelPlugin self, string uri, string prefix, GroupsPkgNamespaces groupsns) -> GroupsModelPlugin
        __init__(GroupsModelPlugin self, GroupsModelPlugin orig) -> GroupsModelPlugin


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            GroupsModelPlugin(GroupsModelPlugin orig)

        Copy constructor for GroupsModelPlugin.

        Parameter 'orig' is the GroupsModelPlugin instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            GroupsModelPlugin(string uri, string prefix,
        GroupsPkgNamespaces groupsns)

        Creates a new GroupsModelPlugin using the given URI, prefix and
        package namespace.

        Parameter 'uri' is a string, representing the URI of the SBML Level 3
        package implemented by this libSBML package extension.

        Parameter 'prefix' is a string, the XML namespace prefix being used
        for this package.

        Parameter 'groupsns' is a pointer to the namesspaces object
        (GroupsPkgNamespaces) for this package.

        In the XML representation of an SBML document, XML namespaces are
        used to identify the origin of each XML construct used.  XML
        namespaces are identified by their unique resource identifiers (URIs).
        The core SBML specifications stipulate the namespaces that must be
        used for core SBML constructs; for example, all XML elements that
        belong to SBML Level 3 Version 1 Core must be placed in the XML
        namespace identified by the URI
        'http://www.sbml.org/sbml/level3/version1/core'.  Individual SBML
        Level 3 packages define their own XML namespaces; for example, all
        elements belonging to the SBML Level 3 Layout Version 1 package must
        be placed in the XML namespace
        'http://www.sbml.org/sbml/level3/version1/layout/version1/'.

        The SBMLNamespaces object encapsulates SBML Level/Version/namespaces
        information.  It is used to communicate the SBML Level, Version, and
        (in Level 3) packages used in addition to SBML Level 3 Core.  A common
        approach to using libSBML's SBMLNamespaces facilities is to create an
        SBMLNamespaces object somewhere in a program once, then hand that
        object as needed to object constructors that accept SBMLNamespaces as
        arguments.

        """
        this = _libsbml.new_GroupsModelPlugin(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(GroupsModelPlugin self) -> GroupsModelPlugin


        Creates and returns a deep copy of this GroupsModelPlugin object.

        Returns a (deep) copy of this GroupsModelPlugin object.

        """
        return _libsbml.GroupsModelPlugin_clone(self)

    __swig_destroy__ = _libsbml.delete_GroupsModelPlugin
    __del__ = lambda self: None

    def getListOfGroups(self, *args):
        """
        getListOfGroups(GroupsModelPlugin self) -> ListOfGroups
        getListOfGroups(GroupsModelPlugin self) -> ListOfGroups


        Returns the ListOfGroups from this GroupsModelPlugin.

        Returns the ListOfGroups from this GroupsModelPlugin.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addGroup(), createGroup(), getGroup(), getGroup(),
        getNumGroups(), removeGroup(), removeGroup().

        """
        return _libsbml.GroupsModelPlugin_getListOfGroups(self, *args)


    def getGroup(self, *args):
        """
        getGroup(GroupsModelPlugin self, unsigned int n) -> Group
        getGroup(GroupsModelPlugin self, unsigned int n) -> Group
        getGroup(GroupsModelPlugin self, string sid) -> Group
        getGroup(GroupsModelPlugin self, string sid) -> Group


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getGroup(long n)

        Get a Group from the GroupsModelPlugin.

        Parameter 'n' is a long integer representing the index of the Group to
        retrieve.

        Returns the nth Group in the ListOfGroups within this
        GroupsModelPlugin or 'None' if no such object exists..

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addGroup(), createGroup(), getGroup(), getNumGroups(),
        removeGroup(), removeGroup().

        ______________________________________________________________________
        Method variant with the following signature:

            getGroup(string sid)

        Get a Group from the GroupsModelPlugin based on its identifier.

        Parameter 'sid' is a string representing the identifier of the Group
        to retrieve.

        Returns the Group in the ListOfGroups within this GroupsModelPlugin
        with the given 'sid' or 'None' if no such Group exists.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addGroup(), createGroup(), getGroup(), getNumGroups(),
        removeGroup(), removeGroup().

        """
        return _libsbml.GroupsModelPlugin_getGroup(self, *args)


    def addGroup(self, g):
        """
        addGroup(GroupsModelPlugin self, Group g) -> int


        Adds a copy of the given Group to this GroupsModelPlugin.

        Parameter 'g' is the Group object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_PKG_VERSION_MISMATCH

        * LIBSBML_DUPLICATE_OBJECT_ID

        Note: This method should be used with some caution.  The fact that
        this method copies the object passed to it means that the caller will
        be left holding a physically different object instance than the one
        contained inside this object.  Changes made to the original object
        instance (such as resetting attribute values) will not affect the
        instance in this object.  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 other methods on this class
        (particularly a corresponding method whose name begins with the word
        create) for alternatives that do not lead to these issues.

        See also createGroup(), getGroup(), getGroup(), getNumGroups(),
        removeGroup(), removeGroup().

        """
        return _libsbml.GroupsModelPlugin_addGroup(self, g)


    def getNumGroups(self):
        """
        getNumGroups(GroupsModelPlugin self) -> unsigned int


        Get the number of Group objects in this GroupsModelPlugin.

        Returns the number of Group objects in this GroupsModelPlugin.

        See also addGroup(), createGroup(), getGroup(), getGroup(),
        removeGroup(), removeGroup().

        """
        return _libsbml.GroupsModelPlugin_getNumGroups(self)


    def createGroup(self):
        """
        createGroup(GroupsModelPlugin self) -> Group


        Creates a new Group object, adds it to this GroupsModelPlugin object
        and returns the Group object created.

        Returns a new Group object instance.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addGroup(), getGroup(), getGroup(), getNumGroups(),
        removeGroup(), removeGroup().

        """
        return _libsbml.GroupsModelPlugin_createGroup(self)


    def removeGroup(self, *args):
        """
        removeGroup(GroupsModelPlugin self, unsigned int n) -> Group
        removeGroup(GroupsModelPlugin self, string sid) -> Group


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeGroup(long n)

        Removes the nth Group from this GroupsModelPlugin and returns a
        pointer to it.

        Parameter 'n' is a long integer representing the index of the Group to
        remove.

        Returns a pointer to the nth Group in this GroupsModelPlugin.

        WARNING:

        The pointer that is returned by this function is owned by the caller,
        who is responsible for deleting it.  Any changes made to the element
        will not be reflected in any resulting SBML document unless the
        element is added to an SBML Document.  Even in this case, the
        element's deletion is still the responsibility of the caller with two
        exceptions: if it is used as the 'disownedItem' in the
        ListOf.appendAndOwn() or ListOf.insertAndOwn()  functions.  All other
        functions in libsbml add a copy of the element, and do not transfer
        ownership of the pointer.

        See also addGroup(), createGroup(), getGroup(), getGroup(),
        getNumGroups(), removeGroup().

        ______________________________________________________________________
        Method variant with the following signature:

            removeGroup(string sid)

        Removes the Group from this GroupsModelPlugin based on its identifier
        and returns a pointer to it.

        Parameter 'sid' is a string representing the identifier of the Group
        to remove.

        Returns the Group in this GroupsModelPlugin based on the identifier or
        None if no such Group exists.

        WARNING:

        The pointer that is returned by this function is owned by the caller,
        who is responsible for deleting it.  Any changes made to the element
        will not be reflected in any resulting SBML document unless the
        element is added to an SBML Document.  Even in this case, the
        element's deletion is still the responsibility of the caller with two
        exceptions: if it is used as the 'disownedItem' in the
        ListOf.appendAndOwn() or ListOf.insertAndOwn()  functions.  All other
        functions in libsbml add a copy of the element, and do not transfer
        ownership of the pointer.

        See also addGroup(), createGroup(), getGroup(), getGroup(),
        getNumGroups(), removeGroup().

        """
        return _libsbml.GroupsModelPlugin_removeGroup(self, *args)


    def connectToChild(self):
        """
        connectToChild(GroupsModelPlugin self)


        Internal implementation method.

        """
        return _libsbml.GroupsModelPlugin_connectToChild(self)


    def connectToParent(self, base):
        """
        connectToParent(GroupsModelPlugin self, SBase base)


        Internal implementation method.

        """
        return _libsbml.GroupsModelPlugin_connectToParent(self, base)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(GroupsModelPlugin self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.GroupsModelPlugin_enablePackageInternal(self, pkgURI, pkgPrefix, flag)


    def updateSBMLNamespace(self, package, level, version):
        """
        updateSBMLNamespace(GroupsModelPlugin self, string package, unsigned int level, unsigned int version)


        Internal implementation method.

        """
        return _libsbml.GroupsModelPlugin_updateSBMLNamespace(self, package, level, version)


    def getElementBySId(self, id):
        """
        getElementBySId(GroupsModelPlugin self, string id) -> SBase


        Returns the first child element that has the given 'id' in the model-
        wide SId namespace, or 'None' if no such object is found.

        Parameter 'id' is a string representing the id attribute of the object
        to retrieve.

        Returns a pointer to the SBase element with the given 'id'. If no such
        object is found, this method returns 'None.'

        """
        return _libsbml.GroupsModelPlugin_getElementBySId(self, id)


    def getElementByMetaId(self, metaid):
        """
        getElementByMetaId(GroupsModelPlugin self, string metaid) -> SBase


        Returns the first child element that has the given 'metaid', or 'None'
        if no such object is found.

        Parameter 'metaid' is a string representing the metaid attribute of
        the object to retrieve.

        Returns a pointer to the SBase element with the given 'metaid'. If no
        such object is found this method returns 'None.'

        """
        return _libsbml.GroupsModelPlugin_getElementByMetaId(self, metaid)


    def appendFrom(self, model):
        """
        appendFrom(GroupsModelPlugin self, Model model) -> int


        Internal implementation method.

        """
        return _libsbml.GroupsModelPlugin_appendFrom(self, model)


    def copyInformationToNestedLists(self):
        """
        copyInformationToNestedLists(GroupsModelPlugin self)


        For nested groups (Member objects that reference a ListOfMembers
        object), SBO terms, Notes, and Annotation from the parent
        ListOfMembers applies to the child.  This function copies any
        information from any of those three things to all  child
        ListOfMembers, and if that information is not already  set.  After
        calling this function, it is sufficient to check any ListOfMembers to
        see if its SBO term, Notes, or Annotation is set, without further
        checking to see if that element was nested in another Group.

        """
        return _libsbml.GroupsModelPlugin_copyInformationToNestedLists(self)

GroupsModelPlugin_swigregister = _libsbml.GroupsModelPlugin_swigregister
GroupsModelPlugin_swigregister(GroupsModelPlugin)

class Group(SBase):
    """

    [SBML 'groups' package]  Representation of a group of SBML
    components.

    The Group class is the first and most central class in the SBML Level
    3 Groups package.  This class represents a group of entities: a simple
    mechanism for indicating that particular components of an SBML model
    are related in some way.  The nature of the relationship is left up to
    the modeler, and can be clarified by means of annotations on model
    components.  Groups may contain either the same or different types of
    SBML objects, and groups may be nested if desired. There are no
    predefined modeling or mathematical semantics associated with groups.

    The Groups class has one required attribute, 'kind'; two optional
    attributes, 'id' and 'name'; and a single child element,
    ListOfMembers. The membership of a group is determined by the contents
    of the list of members stored in Member objects within the
    ListOfMembers child of a Group object.  Since the Group class of
    objects is derived from SBase, and SBase provides the ability to
    attach SBO terms as well as MIRIAM annotations, the semantics of a
    given group in a model can be made more precise using references to
    external controlled vocabularies and ontologies.

    Group kinds
    ======================================================================

    The attribute 'kind' on Group is used to indicate the nature of the
    group defined by a Group instance.  The 'kind' attribute must always
    have one of the following three possible values:

    * ''classification':' The group represents a class, and its
    members have an is-a relationship to the group.  For example, the
    group could represent a type of molecule such as ATP, and the members
    could be species located in different compartments, thereby
    establishing that the species are pools of the same molecule in
    different locations.

    * ''partonomy':' The group represents a collection of parts, and
    its members have a part-of relationship to the group.  For example,
    the group could represent a cellular structure, and individual
    compartments could be made members of the group to indicate they
    represent subparts of that cellular structure.

    * ''collection':' The grouping is merely a collection for
    convenience, without an implied relationship between the members.  For
    example, the group could be used to collect together multiple
    disparate components of a model -- species, reactions, events --
    involved in a particular phenotype, and apply a common annotation
    rather than having to copy the same annotation to each component
    individually.

    In the libSBML API for Groups, these possible values for the 'kind'
    attribute are programmatically represented as constants so that
    callers will not normally need to deal with text string values.  The
    following are the constants defined for the three values of 'kind'
    (plus an additional constant to represent unrecognized values):

    * GROUP_KIND_CLASSIFICATION

    * GROUP_KIND_PARTONOMY

    * GROUP_KIND_COLLECTION

    * GROUP_KIND_UNKNOWN

    Groups and their members
    ======================================================================

    If an SBML element is referenced by a Group's child Member (directly
    or indirectly), it is considered to be a member of that Group.  If the
    same element is referenced by multiple Member objects, this is
    equivalent to including it just once.  (It is considered best practice
    to avoid this, but does not make for an invalid SBML document.)

    Children of referenced elements are not considered to be members of
    the Group: a KineticLaw of a referenced Reaction is not itself a Group
    member. Even the membership of so-called SBML container classes (e.g.,
    ListOfSpecies, ListOfCompartments, etc.) does not imply inclusion of
    children as members of the Group. The sole exception to this rule is
    the handling of ListOfMembers class, described below.

    Semantics of group memberships
    ======================================================================

    If a Member object within a Group object's ListOfMembers references
    another Group object, it is the referenced Group itself that is
    considered to be a member of the parent Group, not the corresponding
    referenced model component(s).  This is true regardless of whether
    those components themselves happen to point to other components using
    some mechanism defined by another SBML Level 3 package (as happens,
    for example, in the SBML Level 3 Hierarchical Model Composition
    package and its use of SBaseRef).  However, if instead a Member object
    references a ListOfMembers object (using the 'id' attribute permitted
    on ListOfMembers objects), it is the components of that ListOfMembers
    that are considered to be part of the parent Group.  In other words:
    if in some Group G, a Member M references another Group, that Group is
    the member of G; if M references a ListOfMembers, it is the entities
    referenced by the Member objects within the ListOfMembers that are the
    members of G and not the ListOfMembers object itself.

    The implication of this is that any rule that applies to members of a
    group (such the meaning of the 'kind' attribute, or the restrictions
    on the application of 'sboTerm' attributes on a ListOfMembers) applies
    to the child group when referenced by the Group 'id', and to the
    members of the child group when referenced by the ListOfMembers 'id'.
    In an example situation where a parent group includes two Species plus
    a Group which itself contains three other Species, if the parent
    group's ListOfMembers is given an 'sboTerm' attribute value, that SBO
    term applies to the two species and the group, not to the three child
    species members of the second group.  (Note also that in such a case,
    the parent group's 'kind' attribute value would almost certainly be
    ''collection'' or ''partonomy',' and not ''classification',' as two
    species and a group are very unlikely to be classified as the same
    thing.)  In contrast, in the situation where a parent group includes
    two Species plus a ListOfMembers which contains three other Species,
    the parent group's ListOfMembers 'sboTerm' would apply to the five
    Species, and could be more reasonably marked as a ''classification'.'

    In a future version of this SBML Level 3 Groups specification, it may
    be possible to perform set operations on groups, but for now, this
    type of union is the only set operation that is possible.

    Groups are not permitted to be circular: no Member may reference
    itself, its parent ListOfMembers, nor its parent Group. If a Member
    references a Group, the same restrictions apply to that subgroup's
    children: they may not reference the Member, its parent ListOfMembers,
    nor its parent Group, and if any of those children reference a Group,
    the same restrictions apply to them, etc.

    If a Member has a 'idRef' or 'metaIdRef' attribute which references an
    object from a namespace that is not understood by the interpreter of
    the SBML model, that Member must be ignored. The referenced object
    will not be understood by the interpreter, and therefore has no need
    to become a member of the group. If an interpreter cannot tell whether
    a referenced object does not exist or if exists in an unparsed
    namespace, it may choose to produce a warning.

    See also Member, ListOfMembers, ListOfGroups.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Group, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Group, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(Group self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> Group
        __init__(Group self, unsigned int level, unsigned int version) -> Group
        __init__(Group self, unsigned int level) -> Group
        __init__(Group self) -> Group
        __init__(Group self, GroupsPkgNamespaces groupsns) -> Group
        __init__(Group self, Group orig) -> Group


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            Group(Group orig)

        Copy constructor for Group.

        Parameter 'orig' is the Group instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            Group(long level = GroupsExtension.getDefaultLevel(), long
        version = GroupsExtension.getDefaultVersion(), long pkgVersion =
        GroupsExtension.getDefaultPackageVersion())

        Creates a new Group using the given SBML Level, Version and "groups"
        package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        Group.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this Group.

        Parameter 'pkgVersion' is a long integer, the SBML Groups Version to
        assign to this Group.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            Group(GroupsPkgNamespaces groupsns)

        Creates a new Group using the given GroupsPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'groupsns' is the GroupsPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_Group(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(Group self) -> Group


        Creates and returns a deep copy of this Group object.

        Returns a (deep) copy of this Group object.

        """
        return _libsbml.Group_clone(self)

    __swig_destroy__ = _libsbml.delete_Group
    __del__ = lambda self: None

    def getId(self):
        """
        getId(Group self) -> string


        Returns the value of the 'id' attribute of this Group.

        Returns the value of the 'id' attribute of this Group as a string.

        """
        return _libsbml.Group_getId(self)


    def getName(self):
        """
        getName(Group self) -> string


        Returns the value of the 'name' attribute of this Group.

        Returns the value of the 'name' attribute of this Group as a string.

        """
        return _libsbml.Group_getName(self)


    def getKind(self):
        """
        getKind(Group self) -> GroupKind_t


        Returns the value of the 'kind' attribute of this Group.

        The attribute 'kind' on a Group object is used to indicate the nature
        of the group defined by a particular Group instance.  In the SBML
        Level 3 Version 1 Group specification, there are only three allowable
        values for 'kind':

        * ''classification',' to indicate that the group represents a class,
        and its members have an is-a relationship to the group.

        * ''partonomy',' to indicate that the group represents a collection of
        parts, and its members have a part-of relationship to the group.

        * ''collection',' to indicate that the grouping is merely a collection
        for convenience, without an implied relationship between the members.
        Returns the value of the 'kind' attribute of this Group as a
        GroupKind_t.

        The possible values returned by this method are:

        * GROUP_KIND_CLASSIFICATION

        * GROUP_KIND_PARTONOMY

        * GROUP_KIND_COLLECTION

        * GROUP_KIND_UNKNOWN

        """
        return _libsbml.Group_getKind(self)


    def getKindAsString(self):
        """
        getKindAsString(Group self) -> string


        Returns the value of the 'kind' attribute of this Group.

        The attribute 'kind' on a Group object is used to indicate the nature
        of the group defined by a particular Group instance.  In the SBML
        Level 3 Version 1 Group specification, there are only three allowable
        values for 'kind':

        * ''classification',' to indicate that the group represents a class,
        and its members have an is-a relationship to the group.

        * ''partonomy',' to indicate that the group represents a collection of
        parts, and its members have a part-of relationship to the group.

        * ''collection',' to indicate that the grouping is merely a collection
        for convenience, without an implied relationship between the members.
        Returns the value of the 'kind' attribute of this Group as a string.
        The possible values returned by this method are:

        * ''classification''

        * ''partonomy''

        * ''collection''

        * ''unknown''

        """
        return _libsbml.Group_getKindAsString(self)


    def isSetId(self):
        """
        isSetId(Group self) -> bool


        Predicate returning 'True' if this Group's 'id' attribute is set.

        Returns 'True' if this Group's 'id' attribute has been set, otherwise
        'False' is returned.

        """
        return _libsbml.Group_isSetId(self)


    def isSetName(self):
        """
        isSetName(Group self) -> bool


        Predicate returning 'True' if this Group's 'name' attribute is set.

        Returns 'True' if this Group's 'name' attribute has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.Group_isSetName(self)


    def isSetKind(self):
        """
        isSetKind(Group self) -> bool


        Predicate returning 'True' if this Group's 'kind' attribute is set.

        Returns 'True' if this Group's 'kind' attribute has been set,
        otherwise 'False' is returned.

        The attribute 'kind' on a Group object is used to indicate the nature
        of the group defined by a particular Group instance.  In the SBML
        Level 3 Version 1 Group specification, there are only three allowable
        values for 'kind':

        * ''classification',' to indicate that the group represents a class,
        and its members have an is-a relationship to the group.

        * ''partonomy',' to indicate that the group represents a collection of
        parts, and its members have a part-of relationship to the group.

        * ''collection',' to indicate that the grouping is merely a collection
        for convenience, without an implied relationship between the members.

        """
        return _libsbml.Group_isSetKind(self)


    def setId(self, id):
        """
        setId(Group self, string id) -> int


        Sets the value of the 'id' attribute of this Group.

        Parameter 'id' is string& value of the 'id' attribute to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        Calling this function with 'id' = 'None' or an empty string is
        equivalent to calling unsetId().

        """
        return _libsbml.Group_setId(self, id)


    def setName(self, name):
        """
        setName(Group self, string name) -> int


        Sets the value of the 'name' attribute of this Group.

        Parameter 'name' is string& value of the 'name' attribute to be set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        Calling this function with 'name' = 'None' or an empty string is
        equivalent to calling unsetName().

        """
        return _libsbml.Group_setName(self, name)


    def setKind(self, *args):
        """
        setKind(Group self, GroupKind_t const kind) -> int
        setKind(Group self, string kind) -> int


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            setKind( GroupKind_t kind)

        Sets the value of the 'kind' attribute of this Group.

        Parameter 'kind' is int value of the  'kind' attribute to be set. The
        value must be one of the predefined constants that represent valid
        SBML Level 3 Version 1 Group 'kind' names, which means it must be one
        of the following values:

        * GROUP_KIND_CLASSIFICATION

        * GROUP_KIND_PARTONOMY

        * GROUP_KIND_COLLECTION.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        The attribute 'kind' on a Group object is used to indicate the nature
        of the group defined by a particular Group instance.  In the SBML
        Level 3 Version 1 Group specification, there are only three allowable
        values for 'kind':

        * ''classification',' to indicate that the group represents a class,
        and its members have an is-a relationship to the group.

        * ''partonomy',' to indicate that the group represents a collection of
        parts, and its members have a part-of relationship to the group.

        * ''collection',' to indicate that the grouping is merely a collection
        for convenience, without an implied relationship between the members.

        ______________________________________________________________________
        Method variant with the following signature:

            setKind(string kind)

        Sets the value of the 'kind' attribute of this Group.

        Parameter 'kind' is string& of the 'kind' attribute to be set.  The
        value must be one of the following possible strings:

        * 'classification'

        * 'partonomy'

        * 'collection'

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        The attribute 'kind' on a Group object is used to indicate the nature
        of the group defined by a particular Group instance.  In the SBML
        Level 3 Version 1 Group specification, there are only three allowable
        values for 'kind':

        * ''classification',' to indicate that the group represents a class,
        and its members have an is-a relationship to the group.

        * ''partonomy',' to indicate that the group represents a collection of
        parts, and its members have a part-of relationship to the group.

        * ''collection',' to indicate that the grouping is merely a collection
        for convenience, without an implied relationship between the members.

        """
        return _libsbml.Group_setKind(self, *args)


    def unsetId(self):
        """
        unsetId(Group self) -> int


        Unsets the value of the 'id' attribute of this Group.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Group_unsetId(self)


    def unsetName(self):
        """
        unsetName(Group self) -> int


        Unsets the value of the 'name' attribute of this Group.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Group_unsetName(self)


    def unsetKind(self):
        """
        unsetKind(Group self) -> int


        Unsets the value of the 'kind' attribute of this Group.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        The attribute 'kind' on a Group object is used to indicate the nature
        of the group defined by a particular Group instance.  In the SBML
        Level 3 Version 1 Group specification, there are only three allowable
        values for 'kind':

        * ''classification',' to indicate that the group represents a class,
        and its members have an is-a relationship to the group.

        * ''partonomy',' to indicate that the group represents a collection of
        parts, and its members have a part-of relationship to the group.

        * ''collection',' to indicate that the grouping is merely a collection
        for convenience, without an implied relationship between the members.

        """
        return _libsbml.Group_unsetKind(self)


    def getListOfMembers(self, *args):
        """
        getListOfMembers(Group self) -> ListOfMembers
        getListOfMembers(Group self) -> ListOfMembers


        Returns the ListOfMembers from this Group.

        Using the SBML Level 3 Groups package, the membership of a group is
        determined by the contents of the list of members stored in Member
        objects within the ListOfMembers child of a Group object.

        Returns the ListOfMembers from this Group.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addMember(), createMember(), getMember(), getMember(),
        getNumMembers(), removeMember(), removeMember().

        """
        return _libsbml.Group_getListOfMembers(self, *args)


    def getMember(self, *args):
        """
        getMember(Group self, unsigned int n) -> Member
        getMember(Group self, unsigned int n) -> Member
        getMember(Group self, string sid) -> Member
        getMember(Group self, string sid) -> Member


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getMember(long n)

        Get a Member from the Group.

        Parameter 'n' is a long integer representing the index of the Member
        to retrieve.

        Returns the nth Member in the ListOfMembers within this Group or
        'None' if no such object exists..

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addMember(), createMember(), getMember(), getNumMembers(),
        removeMember(), removeMember().

        ______________________________________________________________________
        Method variant with the following signature:

            getMember(string sid)

        Get a Member from the Group based on its identifier.

        Parameter 'sid' is a string representing the identifier of the Member
        to retrieve.

        Returns the Member in the ListOfMembers within this Group with the
        given 'sid' or 'None' if no such Member exists.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addMember(), createMember(), getMember(), getNumMembers(),
        removeMember(), removeMember().

        """
        return _libsbml.Group_getMember(self, *args)


    def getMemberByIdRef(self, *args):
        """
        getMemberByIdRef(Group self, string sid) -> Member
        getMemberByIdRef(Group self, string sid) -> Member


        Get a Member from the Group based on the element to which it refers.

        Parameter 'sid' is a string representing the 'idRef' attribute of the
        Member object to retrieve.

        Returns the first Member in this Group based on the given idRef
        attribute or None if no such Member exists.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        """
        return _libsbml.Group_getMemberByIdRef(self, *args)


    def addMember(self, m):
        """
        addMember(Group self, Member m) -> int


        Adds a copy of the given Member to this Group.

        Parameter 'm' is the Member object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_PKG_VERSION_MISMATCH

        * LIBSBML_DUPLICATE_OBJECT_ID

        Note: This method should be used with some caution.  The fact that
        this method copies the object passed to it means that the caller will
        be left holding a physically different object instance than the one
        contained inside this object.  Changes made to the original object
        instance (such as resetting attribute values) will not affect the
        instance in this object.  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 other methods on this class
        (particularly a corresponding method whose name begins with the word
        create) for alternatives that do not lead to these issues.

        See also createMember(), getMember(), getMember(), getNumMembers(),
        removeMember(), removeMember().

        """
        return _libsbml.Group_addMember(self, m)


    def getNumMembers(self):
        """
        getNumMembers(Group self) -> unsigned int


        Get the number of Member objects in this Group.

        Returns the number of Member objects in this Group.

        See also addMember(), createMember(), getMember(), getMember(),
        removeMember(), removeMember().

        """
        return _libsbml.Group_getNumMembers(self)


    def createMember(self):
        """
        createMember(Group self) -> Member


        Creates a new Member object, adds it to this Group object and returns
        the Member object created.

        Returns a new Member object instance.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addMember(), getMember(), getMember(), getNumMembers(),
        removeMember(), removeMember().

        """
        return _libsbml.Group_createMember(self)


    def removeMember(self, *args):
        """
        removeMember(Group self, unsigned int n) -> Member
        removeMember(Group self, string sid) -> Member


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeMember(long n)

        Removes the nth Member from this Group and returns a pointer to it.

        Parameter 'n' is a long integer representing the index of the Member
        to remove.

        Returns a pointer to the nth Member in this Group.

        WARNING:

        The pointer that is returned by this function is owned by the caller,
        who is responsible for deleting it.  Any changes made to the element
        will not be reflected in any resulting SBML document unless the
        element is added to an SBML Document.  Even in this case, the
        element's deletion is still the responsibility of the caller with two
        exceptions: if it is used as the 'disownedItem' in the
        ListOf.appendAndOwn() or ListOf.insertAndOwn()  functions.  All other
        functions in libsbml add a copy of the element, and do not transfer
        ownership of the pointer.

        See also addMember(), createMember(), getMember(), getMember(),
        getNumMembers(), removeMember().

        ______________________________________________________________________
        Method variant with the following signature:

            removeMember(string sid)

        Removes the Member from this Group based on its identifier and returns
        a pointer to it.

        Parameter 'sid' is a string representing the identifier of the Member
        to remove.

        Returns the Member in this Group based on the identifier or None if no
        such Member exists.

        WARNING:

        The pointer that is returned by this function is owned by the caller,
        who is responsible for deleting it.  Any changes made to the element
        will not be reflected in any resulting SBML document unless the
        element is added to an SBML Document.  Even in this case, the
        element's deletion is still the responsibility of the caller with two
        exceptions: if it is used as the 'disownedItem' in the
        ListOf.appendAndOwn() or ListOf.insertAndOwn()  functions.  All other
        functions in libsbml add a copy of the element, and do not transfer
        ownership of the pointer.

        See also addMember(), createMember(), getMember(), getMember(),
        getNumMembers(), removeMember().

        """
        return _libsbml.Group_removeMember(self, *args)


    def getElementName(self):
        """
        getElementName(Group self) -> string


        Returns the XML element name of this Group object.

        For Group, the XML element name is always ''group'.'

        Returns the name of this element, i.e. ''group'.'

        """
        return _libsbml.Group_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(Group self) -> int


        Returns the libSBML type code for this Group object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_GROUPS_GROUP.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.Group_getTypeCode(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(Group self) -> bool


        Predicate returning 'True' if all the required attributes for this
        Group object have been set.

        Returns 'True' to indicate that all the required attributes of this
        Group have been set, otherwise 'False' is returned.

        Note: The required attributes for the Group object are:

        * 'kind'

        """
        return _libsbml.Group_hasRequiredAttributes(self)


    def connectToChild(self):
        """
        connectToChild(Group self)


        Internal implementation method.

        """
        return _libsbml.Group_connectToChild(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(Group self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.Group_enablePackageInternal(self, pkgURI, pkgPrefix, flag)


    def updateSBMLNamespace(self, package, level, version):
        """
        updateSBMLNamespace(Group self, string package, unsigned int level, unsigned int version)


        Internal implementation method.

        """
        return _libsbml.Group_updateSBMLNamespace(self, package, level, version)


    def getElementBySId(self, id):
        """
        getElementBySId(Group self, string id) -> SBase


        Returns the first child element that has the given 'id' in the model-
        wide SId namespace, or 'None' if no such object is found.

        Parameter 'id' is a string representing the id attribute of the object
        to retrieve.

        Returns a pointer to the SBase element with the given 'id'. If no such
        object is found, this method returns 'None.'

        """
        return _libsbml.Group_getElementBySId(self, id)


    def getElementByMetaId(self, metaid):
        """
        getElementByMetaId(Group self, string metaid) -> SBase


        Returns the first child element that has the given 'metaid', or 'None'
        if no such object is found.

        Parameter 'metaid' is a string representing the metaid attribute of
        the object to retrieve.

        Returns a pointer to the SBase element with the given 'metaid'. If no
        such object is found this method returns 'None.'

        """
        return _libsbml.Group_getElementByMetaId(self, metaid)

Group_swigregister = _libsbml.Group_swigregister
Group_swigregister(Group)

class Member(SBase):
    """

    [SBML 'groups' package]  The Member class defines what objects are
    parts of a Group.

    The Member class has four optional attributes: id and name, which
    identify  the element, and idRef and metaIdRef which reference the
    identifiers of  other elements. There must be exactly one (and only
    one) method used to  reference another element: either idRef or
    metaIdRef may be defined, but  not both. (Multiple attributes are
    needed to account for the different types  of identifiers that a given
    object may have.) The referenced object  (including, potentially,
    another Group object) is thus made a member of the  group in which the
    Member object is contained.

    Since Member is derived from SBase and, as mentioned above, SBase
    provides  both the ability to attach SBO terms as well as MIRIAM
    annotations, the  semantics of a given member in a model can be made
    more precise by reference  to external controlled vocabularies and
    ontologies.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Member, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Member, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(Member self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> Member
        __init__(Member self, unsigned int level, unsigned int version) -> Member
        __init__(Member self, unsigned int level) -> Member
        __init__(Member self) -> Member
        __init__(Member self, GroupsPkgNamespaces groupsns) -> Member
        __init__(Member self, Member orig) -> Member


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            Member(Member orig)

        Copy constructor for Member.

        Parameter 'orig' is the Member instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            Member(long level = GroupsExtension.getDefaultLevel(), long
        version = GroupsExtension.getDefaultVersion(), long pkgVersion =
        GroupsExtension.getDefaultPackageVersion())

        Creates a new Member using the given SBML Level, Version and
        "groups" package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        Member.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this Member.

        Parameter 'pkgVersion' is a long integer, the SBML Groups Version to
        assign to this Member.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            Member(GroupsPkgNamespaces groupsns)

        Creates a new Member using the given GroupsPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'groupsns' is the GroupsPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_Member(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(Member self) -> Member


        Creates and returns a deep copy of this Member object.

        Returns a (deep) copy of this Member object.

        """
        return _libsbml.Member_clone(self)

    __swig_destroy__ = _libsbml.delete_Member
    __del__ = lambda self: None

    def getId(self):
        """
        getId(Member self) -> string


        Returns the value of the 'id' attribute of this Member.

        Returns the value of the 'id' attribute of this Member as a string.

        """
        return _libsbml.Member_getId(self)


    def getName(self):
        """
        getName(Member self) -> string


        Returns the value of the 'name' attribute of this Member.

        Returns the value of the 'name' attribute of this Member as a string.

        """
        return _libsbml.Member_getName(self)


    def getIdRef(self):
        """
        getIdRef(Member self) -> string


        Returns the value of the 'idRef' attribute of this Member.

        Returns the value of the 'idRef' attribute of this Member as a string.

        """
        return _libsbml.Member_getIdRef(self)


    def getMetaIdRef(self):
        """
        getMetaIdRef(Member self) -> string


        Returns the value of the 'metaIdRef' attribute of this Member.

        Returns the value of the 'metaIdRef' attribute of this Member as a
        string.

        """
        return _libsbml.Member_getMetaIdRef(self)


    def isSetId(self):
        """
        isSetId(Member self) -> bool


        Predicate returning 'True' if this Member's 'id' attribute is set.

        Returns 'True' if this Member's 'id' attribute has been set, otherwise
        'False' is returned.

        """
        return _libsbml.Member_isSetId(self)


    def isSetName(self):
        """
        isSetName(Member self) -> bool


        Predicate returning 'True' if this Member's 'name' attribute is set.

        Returns 'True' if this Member's 'name' attribute has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.Member_isSetName(self)


    def isSetIdRef(self):
        """
        isSetIdRef(Member self) -> bool


        Predicate returning 'True' if this Member's 'idRef' attribute is set.

        Returns 'True' if this Member's 'idRef' attribute has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.Member_isSetIdRef(self)


    def isSetMetaIdRef(self):
        """
        isSetMetaIdRef(Member self) -> bool


        Predicate returning 'True' if this Member's 'metaIdRef' attribute is
        set.

        Returns 'True' if this Member's 'metaIdRef' attribute has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.Member_isSetMetaIdRef(self)


    def setId(self, id):
        """
        setId(Member self, string id) -> int


        Sets the value of the 'id' attribute of this Member.

        Parameter 'id' is string& value of the 'id' attribute to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        Calling this function with 'id' = 'None' or an empty string is
        equivalent to calling unsetId().

        """
        return _libsbml.Member_setId(self, id)


    def setName(self, name):
        """
        setName(Member self, string name) -> int


        Sets the value of the 'name' attribute of this Member.

        Parameter 'name' is string& value of the 'name' attribute to be set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        Calling this function with 'name' = 'None' or an empty string is
        equivalent to calling unsetName().

        """
        return _libsbml.Member_setName(self, name)


    def setIdRef(self, idRef):
        """
        setIdRef(Member self, string idRef) -> int


        Sets the value of the 'idRef' attribute of this Member.

        Parameter 'idRef' is string& value of the 'idRef' attribute to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Member_setIdRef(self, idRef)


    def setMetaIdRef(self, metaIdRef):
        """
        setMetaIdRef(Member self, string metaIdRef) -> int


        Sets the value of the 'metaIdRef' attribute of this Member.

        Parameter 'metaIdRef' is string& value of the 'metaIdRef' attribute to
        be set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.Member_setMetaIdRef(self, metaIdRef)


    def unsetId(self):
        """
        unsetId(Member self) -> int


        Unsets the value of the 'id' attribute of this Member.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Member_unsetId(self)


    def unsetName(self):
        """
        unsetName(Member self) -> int


        Unsets the value of the 'name' attribute of this Member.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Member_unsetName(self)


    def unsetIdRef(self):
        """
        unsetIdRef(Member self) -> int


        Unsets the value of the 'idRef' attribute of this Member.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Member_unsetIdRef(self)


    def unsetMetaIdRef(self):
        """
        unsetMetaIdRef(Member self) -> int


        Unsets the value of the 'metaIdRef' attribute of this Member.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Member_unsetMetaIdRef(self)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(Member self, string oldid, string newid)


        Replaces all uses of a given 'SIdRef' type attribute value with
        another value.

        In SBML, object identifiers are of a data type called SId. In SBML
        Level 3, an explicit data type called SIdRef was introduced for
        attribute values that refer to SId values; in previous Levels of SBML,
        this data type did not exist and attributes were simply described to
        as 'referring to an identifier', but the effective data type was the
        same as SIdRef in Level 3.  These and other methods of libSBML refer
        to the type SIdRef for all Levels of SBML, even if the corresponding
        SBML specification did not explicitly name the data type.

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas in MathML content, comparing the referenced
        identifiers to the value of 'oldid'.  If any matches are found, the
        matching values are replaced with 'newid'.  The method does not
        descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.Member_renameSIdRefs(self, oldid, newid)


    def getElementName(self):
        """
        getElementName(Member self) -> string


        Returns the XML element name of this Member object.

        For Member, the XML element name is always ''member'.'

        Returns the name of this element, i.e. ''member'.'

        """
        return _libsbml.Member_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(Member self) -> int


        Returns the libSBML type code for this Member object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_GROUPS_MEMBER.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.Member_getTypeCode(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(Member self) -> bool


        Predicate returning 'True' if all the required attributes for this
        Member object have been set.

        Returns 'True' to indicate that all the required attributes of this
        Member have been set, otherwise 'False' is returned.

        """
        return _libsbml.Member_hasRequiredAttributes(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(Member self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.Member_enablePackageInternal(self, pkgURI, pkgPrefix, flag)


    def getReferencedElement(self):
        """
        getReferencedElement(Member self) -> SBase


        Internal implementation method.

        """
        return _libsbml.Member_getReferencedElement(self)

Member_swigregister = _libsbml.Member_swigregister
Member_swigregister(Member)

class ListOfGroups(ListOf):
    """

    [SBML 'groups' package]  A list of Group objects.

    The SBML Level 3 Groups package provides a means of defining a group
    of entities: a simple mechanism for indicating that particular
    components of an SBML model are related in some way.  A group is
    defined using a Group class object, and all the Group objects in a
    model are stored in the parent Model object within a ListOfGroups
    object.

    A ListOfGroups is optional, but, if present, must contain at least one
    Group object.  In common with other ListOf___ classes in SBML,
    ListOfGroups is derived from SBase. It inherits SBase's attributes
    'metaid' and 'sboTerm', as well as the subcomponents for Annotation
    and Notes, but does not add any new attributes of its own.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfGroups, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfGroups, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ListOfGroups self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ListOfGroups
        __init__(ListOfGroups self, unsigned int level, unsigned int version) -> ListOfGroups
        __init__(ListOfGroups self, unsigned int level) -> ListOfGroups
        __init__(ListOfGroups self) -> ListOfGroups
        __init__(ListOfGroups self, GroupsPkgNamespaces groupsns) -> ListOfGroups
        __init__(ListOfGroups self, ListOfGroups orig) -> ListOfGroups


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfGroups(ListOfGroups orig)

        Copy constructor for ListOfGroups.

        Parameter 'orig' is the ListOfGroups instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfGroups(long level = GroupsExtension.getDefaultLevel(),
        long version = GroupsExtension.getDefaultVersion(), long pkgVersion =
        GroupsExtension.getDefaultPackageVersion())

        Creates a new ListOfGroups using the given SBML Level, Version and
        "groups" package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        ListOfGroups.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this ListOfGroups.

        Parameter 'pkgVersion' is a long integer, the SBML Groups Version to
        assign to this ListOfGroups.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfGroups(GroupsPkgNamespaces groupsns)

        Creates a new ListOfGroups using the given GroupsPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'groupsns' is the GroupsPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_ListOfGroups(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ListOfGroups self) -> ListOfGroups


        Creates and returns a deep copy of this ListOfGroups object.

        Returns a (deep) copy of this ListOfGroups object.

        """
        return _libsbml.ListOfGroups_clone(self)

    __swig_destroy__ = _libsbml.delete_ListOfGroups
    __del__ = lambda self: None

    def get(self, *args):
        """
        get(ListOfGroups self, unsigned int n) -> Group
        get(ListOfGroups self, unsigned int n) -> Group
        get(ListOfGroups self, string sid) -> Group
        get(ListOfGroups self, string sid) -> Group


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a Group from the ListOfGroups.

        Parameter 'n' is a long integer representing the index of the Group to
        retrieve.

        Returns the nth Group in this ListOfGroups. If the index 'n' is
        invalid, 'None' is returned.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addGroup(), createGroup(), get(), getNumGroups(), remove(),
        remove().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a Group from the ListOfGroups based on its identifier.

        Parameter 'sid' is a string representing the identifier of the Group
        to retrieve.

        Returns the Group in this ListOfGroups with the given 'sid' or 'None'
        if no such Group exists.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addGroup(), createGroup(), get(), getNumGroups(), remove(),
        remove().

        """
        return _libsbml.ListOfGroups_get(self, *args)


    def remove(self, *args):
        """
        remove(ListOfGroups self, unsigned int n) -> Group
        remove(ListOfGroups self, string sid) -> Group


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth Group from this ListOfGroups and returns a pointer to
        it.

        Parameter 'n' is a long integer representing the index of the Group to
        remove.

        Returns a pointer to the nth Group in this ListOfGroups.

        WARNING:

        The pointer that is returned by this function is owned by the caller,
        who is responsible for deleting it.  Any changes made to the element
        will not be reflected in any resulting SBML document unless the
        element is added to an SBML Document.  Even in this case, the
        element's deletion is still the responsibility of the caller with two
        exceptions: if it is used as the 'disownedItem' in the
        ListOf.appendAndOwn() or ListOf.insertAndOwn()  functions.  All other
        functions in libsbml add a copy of the element, and do not transfer
        ownership of the pointer.

        See also addGroup(), createGroup(), get(), get(), getNumGroups(),
        remove().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes the Group from this ListOfGroups based on its identifier and
        returns a pointer to it.

        Parameter 'sid' is a string representing the identifier of the Group
        to remove.

        Returns the Group in this ListOfGroups based on the identifier or None
        if no such Group exists.

        WARNING:

        The pointer that is returned by this function is owned by the caller,
        who is responsible for deleting it.  Any changes made to the element
        will not be reflected in any resulting SBML document unless the
        element is added to an SBML Document.  Even in this case, the
        element's deletion is still the responsibility of the caller with two
        exceptions: if it is used as the 'disownedItem' in the
        ListOf.appendAndOwn() or ListOf.insertAndOwn()  functions.  All other
        functions in libsbml add a copy of the element, and do not transfer
        ownership of the pointer.

        See also addGroup(), createGroup(), get(), get(), getNumGroups(),
        remove().

        """
        return _libsbml.ListOfGroups_remove(self, *args)


    def addGroup(self, g):
        """
        addGroup(ListOfGroups self, Group g) -> int


        Adds a copy of the given Group to this ListOfGroups.

        Parameter 'g' is the Group object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_PKG_VERSION_MISMATCH

        * LIBSBML_DUPLICATE_OBJECT_ID

        Note: This method should be used with some caution.  The fact that
        this method copies the object passed to it means that the caller will
        be left holding a physically different object instance than the one
        contained inside this object.  Changes made to the original object
        instance (such as resetting attribute values) will not affect the
        instance in this object.  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 other methods on this class
        (particularly a corresponding method whose name begins with the word
        create) for alternatives that do not lead to these issues.

        See also createGroup(), get(), get(), getNumGroups(), remove(),
        remove().

        """
        return _libsbml.ListOfGroups_addGroup(self, g)


    def getNumGroups(self):
        """
        getNumGroups(ListOfGroups self) -> unsigned int


        Get the number of Group objects in this ListOfGroups.

        Returns the number of Group objects in this ListOfGroups.

        See also addGroup(), createGroup(), get(), get(), remove(), remove().

        """
        return _libsbml.ListOfGroups_getNumGroups(self)


    def createGroup(self):
        """
        createGroup(ListOfGroups self) -> Group


        Creates a new Group object, adds it to this ListOfGroups object and
        returns the Group object created.

        Returns a new Group object instance.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addGroup(), get(), get(), getNumGroups(), remove(), remove().

        """
        return _libsbml.ListOfGroups_createGroup(self)


    def getElementName(self):
        """
        getElementName(ListOfGroups self) -> string


        Returns the XML element name of this ListOfGroups object.

        For ListOfGroups, the XML element name is always ''listOfGroups'.'

        Returns the name of this element, i.e. ''listOfGroups'.'

        """
        return _libsbml.ListOfGroups_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(ListOfGroups self) -> int


        Returns the libSBML type code for this ListOfGroups object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_LIST_OF.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        """
        return _libsbml.ListOfGroups_getTypeCode(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfGroups self) -> int


        Returns the libSBML type code for the SBML objects contained in this
        ListOfGroups object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML typecode for the objects contained in this
        ListOfGroups: SBML_GROUPS_GROUP.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfGroups_getItemTypeCode(self)

ListOfGroups_swigregister = _libsbml.ListOfGroups_swigregister
ListOfGroups_swigregister(ListOfGroups)

class ListOfMembers(ListOf):
    """

    [SBML 'groups' package]  A list of Member objects.

    In the SBML Level 3 Groups package, the membership of a group is
    defined by placing Member objects within a ListOfMembers object
    contained within a Group object.  A ListOfMembers object is optional,
    but, if present, it must contain at least one Member object.  In
    common with other ListOf___ classes in SBML, ListOfMembers is derived
    from SBase.  However, an uncommon feature of ListOfMembers is that it
    has optional 'id' and 'name' attributes that can be used in a manner
    discussed below.

    A ListOfMembers must have one or more Member children. Since
    ListOfMembers is derived from SBase, it inherits the 'sboTerm' and
    'metaid' attributes, as well as the optional children Notes and
    Annotation. Unlike most lists of objects in SBML, however, the
    'sboTerm' attribute and the Notes and Annotation children are taken
    here to apply directly to every SBML element referenced by each child
    Member of this ListOfMembers, if that referenced element has no such
    definition. Thus, if a referenced element has no defined 'sboTerm'
    attribute or child Notes or Annotation objects, that element should be
    considered to now have the 'sboTerm', child Notes, or child Annotation
    of the ListOfMembers.

    If multiple ListOfMembers have child Member elements that reference
    the same SBML element, and more than one ListOfMembers or Member has a
    value for an sboTerm attribute, Notes, or Annotation element, those
    Member elements should be consistent with each other: the 'sboTerm'
    attributes should either be identical, or one should inherit from the
    other; Notes should say the same or similar things; and Annotation
    elements should not conflict. Interpreters may choose to resolve any
    such conflicts arbitrarily.

    An uncommon feature about ListOfMembers is that, if it is referenced
    by a Member of a different Group, the children of the referenced
    ListOfMembers are also considered to be members of the referencing
    group. In this way, groups may be nested semantically to create larger
    groups out of subgroups.

    Semantics of group memberships
    ======================================================================

    If a Member object within a Group object's ListOfMembers references
    another Group object, it is the referenced Group itself that is
    considered to be a member of the parent Group, not the corresponding
    referenced model component(s).  This is true regardless of whether
    those components themselves happen to point to other components using
    some mechanism defined by another SBML Level 3 package (as happens,
    for example, in the SBML Level 3 Hierarchical Model Composition
    package and its use of SBaseRef).  However, if instead a Member object
    references a ListOfMembers object (using the 'id' attribute permitted
    on ListOfMembers objects), it is the components of that ListOfMembers
    that are considered to be part of the parent Group.  In other words:
    if in some Group G, a Member M references another Group, that Group is
    the member of G; if M references a ListOfMembers, it is the entities
    referenced by the Member objects within the ListOfMembers that are the
    members of G and not the ListOfMembers object itself.

    The implication of this is that any rule that applies to members of a
    group (such the meaning of the 'kind' attribute, or the restrictions
    on the application of 'sboTerm' attributes on a ListOfMembers) applies
    to the child group when referenced by the Group 'id', and to the
    members of the child group when referenced by the ListOfMembers 'id'.
    In an example situation where a parent group includes two Species plus
    a Group which itself contains three other Species, if the parent
    group's ListOfMembers is given an 'sboTerm' attribute value, that SBO
    term applies to the two species and the group, not to the three child
    species members of the second group.  (Note also that in such a case,
    the parent group's 'kind' attribute value would almost certainly be
    ''collection'' or ''partonomy',' and not ''classification',' as two
    species and a group are very unlikely to be classified as the same
    thing.)  In contrast, in the situation where a parent group includes
    two Species plus a ListOfMembers which contains three other Species,
    the parent group's ListOfMembers 'sboTerm' would apply to the five
    Species, and could be more reasonably marked as a ''classification'.'

    In a future version of this SBML Level 3 Groups specification, it may
    be possible to perform set operations on groups, but for now, this
    type of union is the only set operation that is possible.

    Groups are not permitted to be circular: no Member may reference
    itself, its parent ListOfMembers, nor its parent Group. If a Member
    references a Group, the same restrictions apply to that subgroup's
    children: they may not reference the Member, its parent ListOfMembers,
    nor its parent Group, and if any of those children reference a Group,
    the same restrictions apply to them, etc.

    If a Member has a 'idRef' or 'metaIdRef' attribute which references an
    object from a namespace that is not understood by the interpreter of
    the SBML model, that Member must be ignored. The referenced object
    will not be understood by the interpreter, and therefore has no need
    to become a member of the group. If an interpreter cannot tell whether
    a referenced object does not exist or if exists in an unparsed
    namespace, it may choose to produce a warning.

    See also Group, Member, ListOfGroups.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfMembers, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfMembers, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ListOfMembers self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ListOfMembers
        __init__(ListOfMembers self, unsigned int level, unsigned int version) -> ListOfMembers
        __init__(ListOfMembers self, unsigned int level) -> ListOfMembers
        __init__(ListOfMembers self) -> ListOfMembers
        __init__(ListOfMembers self, GroupsPkgNamespaces groupsns) -> ListOfMembers
        __init__(ListOfMembers self, ListOfMembers orig) -> ListOfMembers


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfMembers(ListOfMembers orig)

        Copy constructor for ListOfMembers.

        Parameter 'orig' is the ListOfMembers instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfMembers(long level = GroupsExtension.getDefaultLevel(),
        long version = GroupsExtension.getDefaultVersion(), long pkgVersion =
        GroupsExtension.getDefaultPackageVersion())

        Creates a new ListOfMembers using the given SBML Level, Version and
        "groups" package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        ListOfMembers.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this ListOfMembers.

        Parameter 'pkgVersion' is a long integer, the SBML Groups Version to
        assign to this ListOfMembers.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfMembers(GroupsPkgNamespaces groupsns)

        Creates a new ListOfMembers using the given GroupsPkgNamespaces
        object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'groupsns' is the GroupsPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_ListOfMembers(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ListOfMembers self) -> ListOfMembers


        Creates and returns a deep copy of this ListOfMembers object.

        Returns a (deep) copy of this ListOfMembers object.

        """
        return _libsbml.ListOfMembers_clone(self)

    __swig_destroy__ = _libsbml.delete_ListOfMembers
    __del__ = lambda self: None

    def getId(self):
        """
        getId(ListOfMembers self) -> string


        Returns the value of the 'id' attribute of this ListOfMembers.

        Returns the value of the 'id' attribute of this ListOfMembers as a
        string.

        """
        return _libsbml.ListOfMembers_getId(self)


    def getName(self):
        """
        getName(ListOfMembers self) -> string


        Returns the value of the 'name' attribute of this ListOfMembers.

        Returns the value of the 'name' attribute of this ListOfMembers as a
        string.

        """
        return _libsbml.ListOfMembers_getName(self)


    def isSetId(self):
        """
        isSetId(ListOfMembers self) -> bool


        Predicate returning 'True' if this ListOfMembers's 'id' attribute is
        set.

        Returns 'True' if this ListOfMembers's 'id' attribute has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.ListOfMembers_isSetId(self)


    def isSetName(self):
        """
        isSetName(ListOfMembers self) -> bool


        Predicate returning 'True' if this ListOfMembers's 'name' attribute is
        set.

        Returns 'True' if this ListOfMembers's 'name' attribute has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.ListOfMembers_isSetName(self)


    def setId(self, id):
        """
        setId(ListOfMembers self, string id) -> int


        Sets the value of the 'id' attribute of this ListOfMembers.

        Parameter 'id' is string& value of the 'id' attribute to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        Calling this function with 'id' = 'None' or an empty string is
        equivalent to calling unsetId().

        """
        return _libsbml.ListOfMembers_setId(self, id)


    def setName(self, name):
        """
        setName(ListOfMembers self, string name) -> int


        Sets the value of the 'name' attribute of this ListOfMembers.

        Parameter 'name' is string& value of the 'name' attribute to be set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        Calling this function with 'name' = 'None' or an empty string is
        equivalent to calling unsetName().

        """
        return _libsbml.ListOfMembers_setName(self, name)


    def unsetId(self):
        """
        unsetId(ListOfMembers self) -> int


        Unsets the value of the 'id' attribute of this ListOfMembers.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.ListOfMembers_unsetId(self)


    def unsetName(self):
        """
        unsetName(ListOfMembers self) -> int


        Unsets the value of the 'name' attribute of this ListOfMembers.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.ListOfMembers_unsetName(self)


    def get(self, *args):
        """
        get(ListOfMembers self, unsigned int n) -> Member
        get(ListOfMembers self, unsigned int n) -> Member
        get(ListOfMembers self, string sid) -> Member
        get(ListOfMembers self, string sid) -> Member


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a Member from the ListOfMembers.

        Parameter 'n' is a long integer representing the index of the Member
        to retrieve.

        Returns the nth Member in this ListOfMembers. If the index 'n' is
        invalid, 'None' is returned.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addMember(), createMember(), get(), getNumMembers(),
        remove(), remove().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a Member from the ListOfMembers based on its identifier.

        Parameter 'sid' is a string representing the identifier of the Member
        to retrieve.

        Returns the Member in this ListOfMembers with the given 'sid' or
        'None' if no such Member exists.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addMember(), createMember(), get(), getNumMembers(),
        remove(), remove().

        """
        return _libsbml.ListOfMembers_get(self, *args)


    def remove(self, *args):
        """
        remove(ListOfMembers self, unsigned int n) -> Member
        remove(ListOfMembers self, string sid) -> Member


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth Member from this ListOfMembers and returns a pointer
        to it.

        Parameter 'n' is a long integer representing the index of the Member
        to remove.

        Returns a pointer to the nth Member in this ListOfMembers.

        WARNING:

        The pointer that is returned by this function is owned by the caller,
        who is responsible for deleting it.  Any changes made to the element
        will not be reflected in any resulting SBML document unless the
        element is added to an SBML Document.  Even in this case, the
        element's deletion is still the responsibility of the caller with two
        exceptions: if it is used as the 'disownedItem' in the
        ListOf.appendAndOwn() or ListOf.insertAndOwn()  functions.  All other
        functions in libsbml add a copy of the element, and do not transfer
        ownership of the pointer.

        See also addMember(), createMember(), get(), get(), getNumMembers(),
        remove().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes the Member from this ListOfMembers based on its identifier and
        returns a pointer to it.

        Parameter 'sid' is a string representing the identifier of the Member
        to remove.

        Returns the Member in this ListOfMembers based on the identifier or
        None if no such Member exists.

        WARNING:

        The pointer that is returned by this function is owned by the caller,
        who is responsible for deleting it.  Any changes made to the element
        will not be reflected in any resulting SBML document unless the
        element is added to an SBML Document.  Even in this case, the
        element's deletion is still the responsibility of the caller with two
        exceptions: if it is used as the 'disownedItem' in the
        ListOf.appendAndOwn() or ListOf.insertAndOwn()  functions.  All other
        functions in libsbml add a copy of the element, and do not transfer
        ownership of the pointer.

        See also addMember(), createMember(), get(), get(), getNumMembers(),
        remove().

        """
        return _libsbml.ListOfMembers_remove(self, *args)


    def addMember(self, m):
        """
        addMember(ListOfMembers self, Member m) -> int


        Adds a copy of the given Member to this ListOfMembers.

        Parameter 'm' is the Member object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_PKG_VERSION_MISMATCH

        * LIBSBML_DUPLICATE_OBJECT_ID

        Note: This method should be used with some caution.  The fact that
        this method copies the object passed to it means that the caller will
        be left holding a physically different object instance than the one
        contained inside this object.  Changes made to the original object
        instance (such as resetting attribute values) will not affect the
        instance in this object.  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 other methods on this class
        (particularly a corresponding method whose name begins with the word
        create) for alternatives that do not lead to these issues.

        See also createMember(), get(), get(), getNumMembers(), remove(),
        remove().

        """
        return _libsbml.ListOfMembers_addMember(self, m)


    def getNumMembers(self):
        """
        getNumMembers(ListOfMembers self) -> unsigned int


        Get the number of Member objects in this ListOfMembers.

        Returns the number of Member objects in this ListOfMembers.

        See also addMember(), createMember(), get(), get(), remove(),
        remove().

        """
        return _libsbml.ListOfMembers_getNumMembers(self)


    def createMember(self):
        """
        createMember(ListOfMembers self) -> Member


        Creates a new Member object, adds it to this ListOfMembers object and
        returns the Member object created.

        Returns a new Member object instance.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addMember(), get(), get(), getNumMembers(), remove(),
        remove().

        """
        return _libsbml.ListOfMembers_createMember(self)


    def getByIdRef(self, *args):
        """
        getByIdRef(ListOfMembers self, string sid) -> Member
        getByIdRef(ListOfMembers self, string sid) -> Member


        Get a Member from the ListOfMembers based on the element to which it
        refers.

        Parameter 'sid' is a string representing the 'idRef' attribute of the
        Member object to retrieve.

        Returns the first Member in this ListOfMembers based on the given
        idRef attribute or None if no such Member exists.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        """
        return _libsbml.ListOfMembers_getByIdRef(self, *args)


    def getElementName(self):
        """
        getElementName(ListOfMembers self) -> string


        Returns the XML element name of this ListOfMembers object.

        For ListOfMembers, the XML element name is always ''listOfMembers'.'

        Returns the name of this element, i.e. ''listOfMembers'.'

        """
        return _libsbml.ListOfMembers_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(ListOfMembers self) -> int


        Returns the libSBML type code for this ListOfMembers object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_LIST_OF.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        """
        return _libsbml.ListOfMembers_getTypeCode(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfMembers self) -> int


        Returns the libSBML type code for the SBML objects contained in this
        ListOfMembers object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML typecode for the objects contained in this
        ListOfMembers: SBML_GROUPS_MEMBER.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfMembers_getItemTypeCode(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(ListOfMembers self) -> bool


        Predicate returning 'True' if all the required attributes for this
        ListOfMembers object have been set.

        Returns 'True' to indicate that all the required attributes of this
        ListOfMembers have been set, otherwise 'False' is returned.

        """
        return _libsbml.ListOfMembers_hasRequiredAttributes(self)

ListOfMembers_swigregister = _libsbml.ListOfMembers_swigregister
ListOfMembers_swigregister(ListOfMembers)

GroupsUnknown = _libsbml.GroupsUnknown
GroupsNSUndeclared = _libsbml.GroupsNSUndeclared
GroupsElementNotInNs = _libsbml.GroupsElementNotInNs
GroupsDuplicateComponentId = _libsbml.GroupsDuplicateComponentId
GroupsIdSyntaxRule = _libsbml.GroupsIdSyntaxRule
GroupsAttributeRequiredMissing = _libsbml.GroupsAttributeRequiredMissing
GroupsAttributeRequiredMustBeBoolean = _libsbml.GroupsAttributeRequiredMustBeBoolean
GroupsAttributeRequiredMustHaveValue = _libsbml.GroupsAttributeRequiredMustHaveValue
GroupsModelAllowedElements = _libsbml.GroupsModelAllowedElements
GroupsModelEmptyLOElements = _libsbml.GroupsModelEmptyLOElements
GroupsModelLOGroupsAllowedCoreElements = _libsbml.GroupsModelLOGroupsAllowedCoreElements
GroupsModelLOGroupsAllowedCoreAttributes = _libsbml.GroupsModelLOGroupsAllowedCoreAttributes
GroupsGroupAllowedCoreAttributes = _libsbml.GroupsGroupAllowedCoreAttributes
GroupsGroupAllowedCoreElements = _libsbml.GroupsGroupAllowedCoreElements
GroupsGroupAllowedAttributes = _libsbml.GroupsGroupAllowedAttributes
GroupsGroupAllowedElements = _libsbml.GroupsGroupAllowedElements
GroupsGroupKindMustBeGroupKindEnum = _libsbml.GroupsGroupKindMustBeGroupKindEnum
GroupsGroupNameMustBeString = _libsbml.GroupsGroupNameMustBeString
GroupsGroupEmptyLOElements = _libsbml.GroupsGroupEmptyLOElements
GroupsGroupLOMembersAllowedCoreElements = _libsbml.GroupsGroupLOMembersAllowedCoreElements
GroupsGroupLOMembersAllowedCoreAttributes = _libsbml.GroupsGroupLOMembersAllowedCoreAttributes
GroupsGroupLOMembersAllowedAttributes = _libsbml.GroupsGroupLOMembersAllowedAttributes
GroupsLOMembersNameMustBeString = _libsbml.GroupsLOMembersNameMustBeString
GroupsLOMembersConsistentReferences = _libsbml.GroupsLOMembersConsistentReferences
GroupsNotCircularReferences = _libsbml.GroupsNotCircularReferences
GroupsMemberAllowedCoreAttributes = _libsbml.GroupsMemberAllowedCoreAttributes
GroupsMemberAllowedCoreElements = _libsbml.GroupsMemberAllowedCoreElements
GroupsMemberAllowedAttributes = _libsbml.GroupsMemberAllowedAttributes
GroupsMemberNameMustBeString = _libsbml.GroupsMemberNameMustBeString
GroupsMemberIdRefMustBeSBase = _libsbml.GroupsMemberIdRefMustBeSBase
GroupsMemberMetaIdRefMustBeSBase = _libsbml.GroupsMemberMetaIdRefMustBeSBase
GroupsMemberIdRefMustBeSId = _libsbml.GroupsMemberIdRefMustBeSId
GroupsMemberMetaIdRefMustBeID = _libsbml.GroupsMemberMetaIdRefMustBeID
class L3v2extendedmathPkgNamespaces(SBMLNamespaces):
    """

    Set of SBML Level + Version + namespace triples.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    SBMLExtensionNamespaces is a template class.  It is extended from
    SBMLNamespaces and is meant to be used by package extensions to store
    the SBML Level, Version within a Level, and package version of the
    SBML Level 3 package implemented by a libSBML package extension.

    Basic principles of SBML package extensions in libSBML
    ======================================================================

    SBML Level 3's package structure permits modular extensions to the
    core SBML format.  In libSBML, support for SBML Level 3 packages is
    provided through optional package extensions that can be plugged into
    libSBML at the time it is built/compiled.  Users of libSBML can thus
    choose which extensions are enabled in their software applications.

    LibSBML defines a number of classes that developers of package
    extensions can use to implement support for an SBML Level 3 package.
    These classes make it easier to extend libSBML objects with new
    attributes and/or subobjects as needed by a particular Level 3
    package. Three overall categories of classes make up libSBML's
    facilities for implementing package extensions.  There are (1) classes
    that serve as base classes meant to be subclassed, (2) template
    classes meant to be instantiated rather than subclassed, and (3)
    support classes that provide utility features. A given package
    implementation for libSBML will take the form of code using these and
    other libSBML classes, placed in a subdirectory of src/sbml/packages/.

    The basic libSBML distribution includes a number of package extensions
    implementing support for officially-endorsed SBML Level 3 packages;
    among these are Flux Balance Constraints ('fbc'), Hierarchical Model
    Composition ('comp'), Layout ('layout'), and Qualitative Models
    ('qual').  They can serve as working examples for developers working
    to implement other packages.

    Extensions in libSBML can currently only be implemented in C++ or C;
    there is no mechanism to implement them first in languages such as
    Java or Python.  However, once implemented in C++ or C, language
    interfaces can be generated semi-automatically using the framework in
    place in libSBML.  (The approach is based on using SWIG and facilities
    in libSBML's build system.)

    """

    __swig_setmethods__ = {}
    for _s in [SBMLNamespaces]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, L3v2extendedmathPkgNamespaces, name, value)
    __swig_getmethods__ = {}
    for _s in [SBMLNamespaces]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, L3v2extendedmathPkgNamespaces, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_L3v2extendedmathPkgNamespaces
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(SBMLExtensionNamespaces<(L3v2extendedmathExtension)> self, unsigned int level, unsigned int version, unsigned int pkgVersion, string prefix) -> L3v2extendedmathPkgNamespaces
        __init__(SBMLExtensionNamespaces<(L3v2extendedmathExtension)> self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> L3v2extendedmathPkgNamespaces
        __init__(SBMLExtensionNamespaces<(L3v2extendedmathExtension)> self, unsigned int level, unsigned int version) -> L3v2extendedmathPkgNamespaces
        __init__(SBMLExtensionNamespaces<(L3v2extendedmathExtension)> self, unsigned int level) -> L3v2extendedmathPkgNamespaces
        __init__(SBMLExtensionNamespaces<(L3v2extendedmathExtension)> self) -> L3v2extendedmathPkgNamespaces
        __init__(SBMLExtensionNamespaces<(L3v2extendedmathExtension)> self, L3v2extendedmathPkgNamespaces orig) -> L3v2extendedmathPkgNamespaces


        Set of SBML Level + Version + namespace triples.

        This class of objects is defined by libSBML only and has no direct
        equivalent in terms of SBML components.  This class is not prescribed
        by the SBML specifications, although it is used to implement features
        defined in SBML.

        SBMLExtensionNamespaces is a template class.  It is extended from
        SBMLNamespaces and is meant to be used by package extensions to store
        the SBML Level, Version within a Level, and package version of the
        SBML Level 3 package implemented by a libSBML package extension.

        Basic principles of SBML package extensions in libSBML
        ======================================================================

        SBML Level 3's package structure permits modular extensions to the
        core SBML format.  In libSBML, support for SBML Level 3 packages is
        provided through optional package extensions that can be plugged into
        libSBML at the time it is built/compiled.  Users of libSBML can thus
        choose which extensions are enabled in their software applications.

        LibSBML defines a number of classes that developers of package
        extensions can use to implement support for an SBML Level 3 package.
        These classes make it easier to extend libSBML objects with new
        attributes and/or subobjects as needed by a particular Level 3
        package. Three overall categories of classes make up libSBML's
        facilities for implementing package extensions.  There are (1) classes
        that serve as base classes meant to be subclassed, (2) template
        classes meant to be instantiated rather than subclassed, and (3)
        support classes that provide utility features. A given package
        implementation for libSBML will take the form of code using these and
        other libSBML classes, placed in a subdirectory of src/sbml/packages/.

        The basic libSBML distribution includes a number of package extensions
        implementing support for officially-endorsed SBML Level 3 packages;
        among these are Flux Balance Constraints ('fbc'), Hierarchical Model
        Composition ('comp'), Layout ('layout'), and Qualitative Models
        ('qual').  They can serve as working examples for developers working
        to implement other packages.

        Extensions in libSBML can currently only be implemented in C++ or C;
        there is no mechanism to implement them first in languages such as
        Java or Python.  However, once implemented in C++ or C, language
        interfaces can be generated semi-automatically using the framework in
        place in libSBML.  (The approach is based on using SWIG and facilities
        in libSBML's build system.)

        """
        this = _libsbml.new_L3v2extendedmathPkgNamespaces(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(L3v2extendedmathPkgNamespaces self) -> ISBMLExtensionNamespaces


        Creates and returns a deep copy of this SBMLNamespaces object.

        Returns the (deep) copy of this SBMLNamespaces object.

        """
        return _libsbml.L3v2extendedmathPkgNamespaces_clone(self)


    def getURI(self):
        """
        getURI(L3v2extendedmathPkgNamespaces self) -> string


        Returns a string representing the SBML XML namespace of this object.

        Returns a string representing the SBML namespace that reflects the
        SBML Level and Version of this object.

        """
        return _libsbml.L3v2extendedmathPkgNamespaces_getURI(self)


    def getPackageVersion(self):
        """getPackageVersion(L3v2extendedmathPkgNamespaces self) -> unsigned int"""
        return _libsbml.L3v2extendedmathPkgNamespaces_getPackageVersion(self)


    def getPackageName(self):
        """
        getPackageName(L3v2extendedmathPkgNamespaces self) -> string


        Returns the name of the main package for this namespace.

        Returns the name of the main package for this namespace. 'core' will
        be returned if this namespace is defined in the SBML  core.

        """
        return _libsbml.L3v2extendedmathPkgNamespaces_getPackageName(self)

L3v2extendedmathPkgNamespaces_swigregister = _libsbml.L3v2extendedmathPkgNamespaces_swigregister
L3v2extendedmathPkgNamespaces_swigregister(L3v2extendedmathPkgNamespaces)

class L3v2extendedmathExtension(SBMLExtension):
    """

    Base extension class for the package.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    This is the L3v2extendedmath package extension of the SBMLExtension
    class that is used to facilitate libSBML plug-ins in the
    implementation of an SBMLLevel 3 package.

    """

    __swig_setmethods__ = {}
    for _s in [SBMLExtension]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, L3v2extendedmathExtension, name, value)
    __swig_getmethods__ = {}
    for _s in [SBMLExtension]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, L3v2extendedmathExtension, name)
    __repr__ = _swig_repr

    def getPackageName():
        """
        getPackageName() -> string


        Returns the nickname of the SBML Level 3 package implemented by this
        libSBML extension.

        Returns the package nickname, as a string.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.L3v2extendedmathExtension_getPackageName()

    getPackageName = staticmethod(getPackageName)

    def getDefaultLevel():
        """
        getDefaultLevel() -> unsigned int


        Returns the default SBML Level implemented by this libSBML extension.

        Returns the SBML Level, as a long integereger.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.L3v2extendedmathExtension_getDefaultLevel()

    getDefaultLevel = staticmethod(getDefaultLevel)

    def getDefaultVersion():
        """
        getDefaultVersion() -> unsigned int


        Returns the default SBML Version implemented by this libSBML
        extension.

        Returns the Version within the default SBML Level, as a long
        integereger.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.L3v2extendedmathExtension_getDefaultVersion()

    getDefaultVersion = staticmethod(getDefaultVersion)

    def getDefaultPackageVersion():
        """
        getDefaultPackageVersion() -> unsigned int


        Returns the default version of the SBML Level 3 package implemented by
        this libSBML extension.

        Returns the default version number of the SBML Level 3 package
        definition, as a long integereger.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.L3v2extendedmathExtension_getDefaultPackageVersion()

    getDefaultPackageVersion = staticmethod(getDefaultPackageVersion)

    def getXmlnsL3V1V1():
        """
        getXmlnsL3V1V1() -> string


        Returns the XML namespace URI of the SBML Level 3 package implemented
        by this libSBML extension.

        Returns the XML namespace, as a string.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.L3v2extendedmathExtension_getXmlnsL3V1V1()

    getXmlnsL3V1V1 = staticmethod(getXmlnsL3V1V1)

    def getXmlnsL3V2():
        """
        getXmlnsL3V2() -> string


        Returns the XML namespace URI of the SBML Level 3 package
        automatically included in L3V2.

        Returns the XML namespace, as a string.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.L3v2extendedmathExtension_getXmlnsL3V2()

    getXmlnsL3V2 = staticmethod(getXmlnsL3V2)

    def __init__(self, *args):
        """
        __init__(L3v2extendedmathExtension self) -> L3v2extendedmathExtension
        __init__(L3v2extendedmathExtension self, L3v2extendedmathExtension orig) -> L3v2extendedmathExtension


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            L3v2extendedmathExtension()

        Creates a new L3v2extendedmathExtension instance.

        ______________________________________________________________________
        Method variant with the following signature:

            L3v2extendedmathExtension(L3v2extendedmathExtension orig)

        Copy constructor for L3v2extendedmathExtension.

        Parameter 'orig' is the L3v2extendedmathExtension instance to copy.

        """
        this = _libsbml.new_L3v2extendedmathExtension(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(L3v2extendedmathExtension self) -> L3v2extendedmathExtension


        Creates and returns a deep copy of this L3v2extendedmathExtension
        object.

        Returns a (deep) copy of this L3v2extendedmathExtension object.

        """
        return _libsbml.L3v2extendedmathExtension_clone(self)

    __swig_destroy__ = _libsbml.delete_L3v2extendedmathExtension
    __del__ = lambda self: None

    def getName(self):
        """
        getName(L3v2extendedmathExtension self) -> string


        Returns the name of this SBML Level 3 package ('l3v2extendedmath').

        Returns a string representing the name of this package
        ('l3v2extendedmath').

        """
        return _libsbml.L3v2extendedmathExtension_getName(self)


    def getURI(self, sbmlLevel, sbmlVersion, pkgVersion):
        """
        getURI(L3v2extendedmathExtension self, unsigned int sbmlLevel, unsigned int sbmlVersion, unsigned int pkgVersion) -> string


        Returns a string representing the SBML XML namespace of this SBML
        Level 3 package.

        Parameter 'sbmlLevel' is the level of SBML.

        Parameter 'sbmlVersion' is the version of SBML.

        Parameter 'pkgVersion' is the version of this package.

        Returns a string representing the name of this package
        ('l3v2extendedmath').

        The namespace URI constructed by this method corresponds to the
        combination of the Level and Version of SBML, and the Version of the
        SBML Level 3 package. (At the time of this writing, the only SBML
        Level that supports packages is Level 3, so the value of 'sbmlLevel'
        is necessarily always 3.)

        """
        return _libsbml.L3v2extendedmathExtension_getURI(self, sbmlLevel, sbmlVersion, pkgVersion)


    def getLevel(self, uri):
        """
        getLevel(L3v2extendedmathExtension self, string uri) -> unsigned int


        Returns the SBML Level for the given URI of this package.

        Parameter 'uri' is the string of the URI that represents one of the
        versions of the 'l3v2extendedmath' package.

        Returns the SBML Level for the given URI of this package, or '0' if
        the given URI is invalid, or for a different package.

        """
        return _libsbml.L3v2extendedmathExtension_getLevel(self, uri)


    def getVersion(self, uri):
        """
        getVersion(L3v2extendedmathExtension self, string uri) -> unsigned int


        Returns the Version within the SBML Level for the given URI of this
        package.

        Parameter 'uri' is the string of the URI that represents one of the
        versions of the 'l3v2extendedmath' package.

        Returns the SBML Version within the SBML Level for the given URI of
        this package, or '0' if the given URI is invalid, or for a different
        package.

        """
        return _libsbml.L3v2extendedmathExtension_getVersion(self, uri)


    def getPackageVersion(self, uri):
        """
        getPackageVersion(L3v2extendedmathExtension self, string uri) -> unsigned int


        Returns the SBML Level 3 package version for the given URI of this
        package.

        Parameter 'uri' is the string of the URI that represents one of the
        versions of the 'l3v2extendedmath' package.

        Returns the version of the SBML Level 3 package for the given URI of
        this package, or '0' if the given URI is invalid, or for a different
        package.

        """
        return _libsbml.L3v2extendedmathExtension_getPackageVersion(self, uri)


    def getSBMLExtensionNamespaces(self, uri):
        """
        getSBMLExtensionNamespaces(L3v2extendedmathExtension self, string uri) -> SBMLNamespaces


        Returns a L3v2extendedmathPkgNamespaces object.

        Parameter 'uri' is the string of the URI that represents one of the
        versions of the 'l3v2extendedmath' package.

        Returns L3v2extendedmathPkgNamespaces object corresponding to the
        given URI of this package, or 'None' if the given URI is not defined
        in the 'l3v2extendedmath' package.

        """
        return _libsbml.L3v2extendedmathExtension_getSBMLExtensionNamespaces(self, uri)


    def getStringFromTypeCode(self, typeCode):
        """
        getStringFromTypeCode(L3v2extendedmathExtension self, int typeCode) -> char const *


        Takes a type code of the "l3v2extendedmath" package and returns a
        string describing the code.

        Parameter 'typeCode' is a libSBML type code defined by the libSBML
        extension implementing support for the SBML Level 3
        "l3v2extendedmath" package.

        Returns a text string representing the type code given by 'typeCode'.
        If the type code is unrecognized for this implementation of the
        libSBML "l3v2extendedmath" package, the string returned will be
        '(Unknown SBML L3v2extendedmath Type)'.

        """
        return _libsbml.L3v2extendedmathExtension_getStringFromTypeCode(self, typeCode)


    def getErrorTable(self, index):
        """
        getErrorTable(L3v2extendedmathExtension self, unsigned int index) -> packageErrorTableEntry


        Internal implementation method.

        """
        return _libsbml.L3v2extendedmathExtension_getErrorTable(self, index)


    def getErrorTableIndex(self, errorId):
        """
        getErrorTableIndex(L3v2extendedmathExtension self, unsigned int errorId) -> unsigned int


        Internal implementation method.

        """
        return _libsbml.L3v2extendedmathExtension_getErrorTableIndex(self, errorId)


    def getErrorIdOffset(self):
        """
        getErrorIdOffset(L3v2extendedmathExtension self) -> unsigned int


        Internal implementation method.

        """
        return _libsbml.L3v2extendedmathExtension_getErrorIdOffset(self)


    def init():
        """
        init()


        Internal implementation method.

        """
        return _libsbml.L3v2extendedmathExtension_init()

    init = staticmethod(init)
L3v2extendedmathExtension_swigregister = _libsbml.L3v2extendedmathExtension_swigregister
L3v2extendedmathExtension_swigregister(L3v2extendedmathExtension)

def L3v2extendedmathExtension_getPackageName():
    """
    L3v2extendedmathExtension_getPackageName() -> string


    Returns the nickname of the SBML Level 3 package implemented by this
    libSBML extension.

    Returns the package nickname, as a string.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.L3v2extendedmathExtension_getPackageName()

def L3v2extendedmathExtension_getDefaultLevel():
    """
    L3v2extendedmathExtension_getDefaultLevel() -> unsigned int


    Returns the default SBML Level implemented by this libSBML extension.

    Returns the SBML Level, as a long integereger.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.L3v2extendedmathExtension_getDefaultLevel()

def L3v2extendedmathExtension_getDefaultVersion():
    """
    L3v2extendedmathExtension_getDefaultVersion() -> unsigned int


    Returns the default SBML Version implemented by this libSBML
    extension.

    Returns the Version within the default SBML Level, as a long
    integereger.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.L3v2extendedmathExtension_getDefaultVersion()

def L3v2extendedmathExtension_getDefaultPackageVersion():
    """
    L3v2extendedmathExtension_getDefaultPackageVersion() -> unsigned int


    Returns the default version of the SBML Level 3 package implemented by
    this libSBML extension.

    Returns the default version number of the SBML Level 3 package
    definition, as a long integereger.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.L3v2extendedmathExtension_getDefaultPackageVersion()

def L3v2extendedmathExtension_getXmlnsL3V1V1():
    """
    L3v2extendedmathExtension_getXmlnsL3V1V1() -> string


    Returns the XML namespace URI of the SBML Level 3 package implemented
    by this libSBML extension.

    Returns the XML namespace, as a string.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.L3v2extendedmathExtension_getXmlnsL3V1V1()

def L3v2extendedmathExtension_getXmlnsL3V2():
    """
    L3v2extendedmathExtension_getXmlnsL3V2() -> string


    Returns the XML namespace URI of the SBML Level 3 package
    automatically included in L3V2.

    Returns the XML namespace, as a string.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.L3v2extendedmathExtension_getXmlnsL3V2()

def L3v2extendedmathExtension_init():
    """
    L3v2extendedmathExtension_init()


    Internal implementation method.

    """
    return _libsbml.L3v2extendedmathExtension_init()

class L3v2extendedmathSBMLDocumentPlugin(SBMLDocumentPlugin):
    """

    Extension of SBMLDocument.

    """

    __swig_setmethods__ = {}
    for _s in [SBMLDocumentPlugin]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, L3v2extendedmathSBMLDocumentPlugin, name, value)
    __swig_getmethods__ = {}
    for _s in [SBMLDocumentPlugin]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, L3v2extendedmathSBMLDocumentPlugin, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(L3v2extendedmathSBMLDocumentPlugin self, string uri, string prefix, L3v2extendedmathPkgNamespaces l3v2extendedmathns) -> L3v2extendedmathSBMLDocumentPlugin
        __init__(L3v2extendedmathSBMLDocumentPlugin self, L3v2extendedmathSBMLDocumentPlugin orig) -> L3v2extendedmathSBMLDocumentPlugin


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            L3v2extendedmathSBMLDocumentPlugin(string uri, string prefix,
        L3v2extendedmathPkgNamespaces l3v2extendedmathns)

        Creates a new L3v2extendedmathSBMLDocumentPlugin using the given URI,
        prefix and package namespace.

        Parameter 'uri' is a string, representing the URI of the SBML Level 3
        package implemented by this libSBML package extension.

        Parameter 'prefix' is a string, the XML namespace prefix being used
        for this package.

        Parameter 'l3v2extendedmathns' is a pointer to the namesspaces object
        (L3v2extendedmathPkgNamespaces) for this package.

        In the XML representation of an SBML document, XML namespaces are
        used to identify the origin of each XML construct used.  XML
        namespaces are identified by their unique resource identifiers (URIs).
        The core SBML specifications stipulate the namespaces that must be
        used for core SBML constructs; for example, all XML elements that
        belong to SBML Level 3 Version 1 Core must be placed in the XML
        namespace identified by the URI
        'http://www.sbml.org/sbml/level3/version1/core'.  Individual SBML
        Level 3 packages define their own XML namespaces; for example, all
        elements belonging to the SBML Level 3 Layout Version 1 package must
        be placed in the XML namespace
        'http://www.sbml.org/sbml/level3/version1/layout/version1/'.

        The SBMLNamespaces object encapsulates SBML Level/Version/namespaces
        information.  It is used to communicate the SBML Level, Version, and
        (in Level 3) packages used in addition to SBML Level 3 Core.  A common
        approach to using libSBML's SBMLNamespaces facilities is to create an
        SBMLNamespaces object somewhere in a program once, then hand that
        object as needed to object constructors that accept SBMLNamespaces as
        arguments.

        ______________________________________________________________________
        Method variant with the following signature:

            L3v2extendedmathSBMLDocumentPlugin(L3v2extendedmathSBMLDocume
        ntPlugin orig)

        Copy constructor for L3v2extendedmathSBMLDocumentPlugin.

        Parameter 'orig' is the L3v2extendedmathSBMLDocumentPlugin instance to
        copy.

        """
        this = _libsbml.new_L3v2extendedmathSBMLDocumentPlugin(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(L3v2extendedmathSBMLDocumentPlugin self) -> L3v2extendedmathSBMLDocumentPlugin


        Creates and returns a deep copy of this
        L3v2extendedmathSBMLDocumentPlugin object.

        Returns a (deep) copy of this L3v2extendedmathSBMLDocumentPlugin
        object.

        """
        return _libsbml.L3v2extendedmathSBMLDocumentPlugin_clone(self)

    __swig_destroy__ = _libsbml.delete_L3v2extendedmathSBMLDocumentPlugin
    __del__ = lambda self: None

    def isCompFlatteningImplemented(self):
        """
        isCompFlatteningImplemented(L3v2extendedmathSBMLDocumentPlugin self) -> bool


        Internal implementation method.

        """
        return _libsbml.L3v2extendedmathSBMLDocumentPlugin_isCompFlatteningImplemented(self)


    def checkConsistency(self):
        """
        checkConsistency(L3v2extendedmathSBMLDocumentPlugin self) -> unsigned int


        Internal implementation method.

        """
        return _libsbml.L3v2extendedmathSBMLDocumentPlugin_checkConsistency(self)

L3v2extendedmathSBMLDocumentPlugin_swigregister = _libsbml.L3v2extendedmathSBMLDocumentPlugin_swigregister
L3v2extendedmathSBMLDocumentPlugin_swigregister(L3v2extendedmathSBMLDocumentPlugin)

class L3v2extendedmathASTPlugin(ASTBasePlugin):
    """

    Extension of AST.

    """

    __swig_setmethods__ = {}
    for _s in [ASTBasePlugin]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, L3v2extendedmathASTPlugin, name, value)
    __swig_getmethods__ = {}
    for _s in [ASTBasePlugin]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, L3v2extendedmathASTPlugin, name)
    __repr__ = _swig_repr

    def clone(self):
        """
        clone(L3v2extendedmathASTPlugin self) -> L3v2extendedmathASTPlugin


        Creates and returns a deep copy of this L3v2extendedmathASTPlugin
        object.

        Returns the (deep) copy of this L3v2extendedmathASTPlugin object.

        """
        return _libsbml.L3v2extendedmathASTPlugin_clone(self)

    __swig_destroy__ = _libsbml.delete_L3v2extendedmathASTPlugin
    __del__ = lambda self: None

    def hasCorrectNamespace(self, namespaces):
        """
        hasCorrectNamespace(L3v2extendedmathASTPlugin self, SBMLNamespaces namespaces) -> bool




        """
        return _libsbml.L3v2extendedmathASTPlugin_hasCorrectNamespace(self, namespaces)


    def __init__(self, *args):
        """
        __init__(L3v2extendedmathASTPlugin self) -> L3v2extendedmathASTPlugin
        __init__(L3v2extendedmathASTPlugin self, L3v2extendedmathASTPlugin orig) -> L3v2extendedmathASTPlugin
        __init__(L3v2extendedmathASTPlugin self, string uri) -> L3v2extendedmathASTPlugin


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            L3v2extendedmathASTPlugin()

        Creates a new L3v2extendedmathASTPlugin object.

        ______________________________________________________________________
        Method variant with the following signature:

            L3v2extendedmathASTPlugin(string &uri)

        ______________________________________________________________________
        Method variant with the following signature:

            L3v2extendedmathASTPlugin(   L3v2extendedmathASTPlugin orig)

        """
        this = _libsbml.new_L3v2extendedmathASTPlugin(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def checkNumArguments(self, function, error):
        """
        checkNumArguments(L3v2extendedmathASTPlugin self, ASTNode function, std::stringstream & error) -> int




        """
        return _libsbml.L3v2extendedmathASTPlugin_checkNumArguments(self, function, error)


    def evaluateASTNode(self, node, m=None):
        """
        evaluateASTNode(L3v2extendedmathASTPlugin self, ASTNode node, Model m=None) -> double
        evaluateASTNode(L3v2extendedmathASTPlugin self, ASTNode node) -> double


        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        return _libsbml.L3v2extendedmathASTPlugin_evaluateASTNode(self, node, m)


    def getUnitDefinitionFromRem(self, uff, node, inKL, reactNo):
        """
        getUnitDefinitionFromRem(L3v2extendedmathASTPlugin self, UnitFormulaFormatter * uff, ASTNode node, bool inKL, int reactNo) -> UnitDefinition


        returns the unitDefinition for the ASTNode from a rem function

        """
        return _libsbml.L3v2extendedmathASTPlugin_getUnitDefinitionFromRem(self, uff, node, inKL, reactNo)


    def getUnitDefinitionFromRateOf(self, uff, node, inKL, reactNo):
        """
        getUnitDefinitionFromRateOf(L3v2extendedmathASTPlugin self, UnitFormulaFormatter * uff, ASTNode node, bool inKL, int reactNo) -> UnitDefinition


        returns the unitDefinition for the ASTNode from a rateOf function

        """
        return _libsbml.L3v2extendedmathASTPlugin_getUnitDefinitionFromRateOf(self, uff, node, inKL, reactNo)


    def getUnitDefinitionFromPackage(self, uff, node, inKL, reactNo):
        """
        getUnitDefinitionFromPackage(L3v2extendedmathASTPlugin self, UnitFormulaFormatter * uff, ASTNode node, bool inKL, int reactNo) -> UnitDefinition




        """
        return _libsbml.L3v2extendedmathASTPlugin_getUnitDefinitionFromPackage(self, uff, node, inKL, reactNo)


    def isLogical(self, type):
        """
        isLogical(L3v2extendedmathASTPlugin self, ASTNodeType_t type) -> bool




        """
        return _libsbml.L3v2extendedmathASTPlugin_isLogical(self, type)


    def allowedInFunctionDefinition(self, type):
        """
        allowedInFunctionDefinition(L3v2extendedmathASTPlugin self, ASTNodeType_t type) -> int


        Check if the node type is known to be allowed inside function
        definitions.

        Function definitions must be able to be evaluated without resort to
        outside information. Therefore, some ASTNodes (like AST_TIME and
        AST_FUNCTION_RATE_OF) are disallowed from appearing there.  This
        function checks whether this is true for a given type: a return value
        of '-1' means the plugin has no knowledge of that type; a return value
        of '1' means the plugin knows that the type is indeed allowed, and a
        return value of '0' means that the plugin knows that the type is not
        allowed.

        """
        return _libsbml.L3v2extendedmathASTPlugin_allowedInFunctionDefinition(self, type)

L3v2extendedmathASTPlugin_swigregister = _libsbml.L3v2extendedmathASTPlugin_swigregister
L3v2extendedmathASTPlugin_swigregister(L3v2extendedmathASTPlugin)

SPECIES_ROLE_UNDEFINED = _libsbml.SPECIES_ROLE_UNDEFINED
SPECIES_ROLE_SUBSTRATE = _libsbml.SPECIES_ROLE_SUBSTRATE
SPECIES_ROLE_PRODUCT = _libsbml.SPECIES_ROLE_PRODUCT
SPECIES_ROLE_SIDESUBSTRATE = _libsbml.SPECIES_ROLE_SIDESUBSTRATE
SPECIES_ROLE_SIDEPRODUCT = _libsbml.SPECIES_ROLE_SIDEPRODUCT
SPECIES_ROLE_MODIFIER = _libsbml.SPECIES_ROLE_MODIFIER
SPECIES_ROLE_ACTIVATOR = _libsbml.SPECIES_ROLE_ACTIVATOR
SPECIES_ROLE_INHIBITOR = _libsbml.SPECIES_ROLE_INHIBITOR
SPECIES_ROLE_INVALID = _libsbml.SPECIES_ROLE_INVALID
class Point(SBase):
    """

    [SBML 'layout' package]

    Representation of a point.

    A point is specified via the required attributes 'x', 'y' and an
    optional attribute 'z', all of which are of type double. If the
    attribute z is not specified, the object is a two dimensional object.
    The Point class also has an optional attribute id of type SId. While
    not used in the "layout" package, it can be used by programs to
    refer to the elements.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Point, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Point, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(Point self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> Point
        __init__(Point self, unsigned int level, unsigned int version) -> Point
        __init__(Point self, unsigned int level) -> Point
        __init__(Point self) -> Point
        __init__(Point self, LayoutPkgNamespaces layoutns) -> Point
        __init__(Point self, Point orig) -> Point
        __init__(Point self, LayoutPkgNamespaces layoutns, double x, double y, double z=0.0) -> Point
        __init__(Point self, LayoutPkgNamespaces layoutns, double x, double y) -> Point
        __init__(Point self, XMLNode node, unsigned int l2version=4) -> Point
        __init__(Point self, XMLNode node) -> Point


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            Point( Point orig)

        Copy constructor.

        Parameter 'orig' is the instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            Point(LayoutPkgNamespaces layoutns)

        Constructor.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'layoutns' is the LayoutPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        ______________________________________________________________________
        Method variant with the following signature:

            Point(LayoutPkgNamespaces layoutns, double x, double y,
        double z =0.0)

        Creates a new point with the given coordinates.

        ______________________________________________________________________
        Method variant with the following signature:

            Point(long level      = LayoutExtension.getDefaultLevel(),
        long version    = LayoutExtension.getDefaultVersion(), long pkgVersion
        = LayoutExtension.getDefaultPackageVersion())

        Creates a new point with x,y and z set to 0.0.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            Point(XMLNode node, long l2version = 4)

        Creates a new Point from the given XMLNode

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        this = _libsbml.new_Point(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_Point
    __del__ = lambda self: None

    def x(self):
        """
        x(Point self) -> double


        Returns the x offset.

        """
        return _libsbml.Point_x(self)


    def y(self):
        """
        y(Point self) -> double


        Returns the y offset.

        """
        return _libsbml.Point_y(self)


    def z(self):
        """
        z(Point self) -> double


        Returns the z offset.

        """
        return _libsbml.Point_z(self)


    def getXOffset(self):
        """
        getXOffset(Point self) -> double


        Returns the x offset.

        """
        return _libsbml.Point_getXOffset(self)


    def getYOffset(self):
        """
        getYOffset(Point self) -> double


        Returns the y offset.

        """
        return _libsbml.Point_getYOffset(self)


    def getZOffset(self):
        """
        getZOffset(Point self) -> double


        Returns the z offset.

        """
        return _libsbml.Point_getZOffset(self)


    def setX(self, x):
        """
        setX(Point self, double x)


        Sets the x offset.

        """
        return _libsbml.Point_setX(self, x)


    def setY(self, y):
        """
        setY(Point self, double y)


        Sets the y offset.

        """
        return _libsbml.Point_setY(self, y)


    def setZ(self, z):
        """
        setZ(Point self, double z)


        Sets the z offset.

        """
        return _libsbml.Point_setZ(self, z)


    def setXOffset(self, x):
        """
        setXOffset(Point self, double x)


        Sets the x offset.

        """
        return _libsbml.Point_setXOffset(self, x)


    def setYOffset(self, y):
        """
        setYOffset(Point self, double y)


        Sets the y offset.

        """
        return _libsbml.Point_setYOffset(self, y)


    def setZOffset(self, z):
        """
        setZOffset(Point self, double z)


        Sets the z offset.

        """
        return _libsbml.Point_setZOffset(self, z)


    def setOffsets(self, x, y, z=0.0):
        """
        setOffsets(Point self, double x, double y, double z=0.0)
        setOffsets(Point self, double x, double y)


        Sets the coordinates to the given values.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        return _libsbml.Point_setOffsets(self, x, y, z)


    def getZOffsetExplicitlySet(self):
        """
        getZOffsetExplicitlySet(Point self) -> bool




        """
        return _libsbml.Point_getZOffsetExplicitlySet(self)


    def initDefaults(self):
        """
        initDefaults(Point self)


        Sets the Z offset to 0.0.

        """
        return _libsbml.Point_initDefaults(self)


    def getId(self):
        """
        getId(Point self) -> string


        Returns the value of the 'id' attribute of this Point.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns the id of this Point.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is now recommended to use the
        getIdAttribute() function instead.

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.Point_getId(self)


    def isSetId(self):
        """
        isSetId(Point self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        Point's 'id' attribute has been set.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns 'True' if the 'id' attribute of this SBML object is set,
        'False' otherwise.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is recommended that callers use
        isSetIdAttribute() instead.

        See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(),
        isSetIdAttribute().

        """
        return _libsbml.Point_isSetId(self)


    def setId(self, sid):
        """
        setId(Point self, string sid) -> int


        Sets the value of the 'id' attribute of this Point.

        The string 'sid' is copied.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Parameter 'sid' is the string to use as the identifier of this object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.Point_setId(self, sid)


    def unsetId(self):
        """
        unsetId(Point self) -> int


        Unsets the value of the 'id' attribute of this Point.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.Point_unsetId(self)


    def setElementName(self, name):
        """
        setElementName(Point self, string name)


        Sets the element name to be returned by getElementName().

        """
        return _libsbml.Point_setElementName(self, name)


    def getElementName(self):
        """
        getElementName(Point self) -> string


        Returns the XML element name of this SBML object.

        Returns the string of the name of this element.

        """
        return _libsbml.Point_getElementName(self)


    def clone(self):
        """
        clone(Point self) -> Point


        Creates and returns a deep copy of this Point.

        Returns a (deep) copy of this Point.

        """
        return _libsbml.Point_clone(self)


    def getTypeCode(self):
        """
        getTypeCode(Point self) -> int


        Returns the libSBML type code of this object instance.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_LAYOUT_POINT.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.Point_getTypeCode(self)


    def toXML(self, name):
        """
        toXML(Point self, string name) -> XMLNode


        Creates an XMLNode object from this.

        """
        return _libsbml.Point_toXML(self, name)

Point_swigregister = _libsbml.Point_swigregister
Point_swigregister(Point)

class Dimensions(SBase):
    """

    [SBML 'layout' package]

    Spatial dimensions of a 2D or 3D shape.

    A dimension is specified via the required attributes width, height,
    and an optional attribute depth, all of which are of type double. If
    the attribute depth is not specified, the object is a two dimensional
    object. The width attribute of Dimensions specifies the size of the
    object in the direction of the positive x axis, the height attribute
    specifies the size of the object along the positive y axis and the
    depth attribute specifies the size of the object along the positive z
    axis. All sizes for Dimensions objects are positive values, and so the
    attributes are not allowed to take negative values.  The Dimensions
    class also has an optional attribute id of type SId. While not used in
    the "layout" package, it can be used by programs to refer to the
    elements.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Dimensions, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Dimensions, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(Dimensions self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> Dimensions
        __init__(Dimensions self, unsigned int level, unsigned int version) -> Dimensions
        __init__(Dimensions self, unsigned int level) -> Dimensions
        __init__(Dimensions self) -> Dimensions
        __init__(Dimensions self, LayoutPkgNamespaces layoutns) -> Dimensions
        __init__(Dimensions self, Dimensions orig) -> Dimensions
        __init__(Dimensions self, LayoutPkgNamespaces layoutns, double w, double h, double d=0.0) -> Dimensions
        __init__(Dimensions self, LayoutPkgNamespaces layoutns, double w, double h) -> Dimensions
        __init__(Dimensions self, XMLNode node, unsigned int l2version=4) -> Dimensions
        __init__(Dimensions self, XMLNode node) -> Dimensions


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            Dimensions(LayoutPkgNamespaces layoutns, double w, double h,
        double d = 0.0)

        Creates a new Dimensions object with the given sizes.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            Dimensions(LayoutPkgNamespaces layoutns)

        Creates a new Dimensions object with the given LayoutPkgNamespaces
        object and with all sizes set to 0.0.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'layoutns' is the LayoutPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        ______________________________________________________________________
        Method variant with the following signature:

            Dimensions(Dimensions orig)

        Copy constructor.

        Parameter 'orig' is the instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            Dimensions(long level      =
        LayoutExtension.getDefaultLevel(), long version    =
        LayoutExtension.getDefaultVersion(), long pkgVersion =
        LayoutExtension.getDefaultPackageVersion())

        Creates a new Dimensions object with the given level, version, and
        package version and with all sizes set to 0.0.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            Dimensions(XMLNode node, long l2version = 4)

        Creates a new Dimensions object from the given XMLNode

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        this = _libsbml.new_Dimensions(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_Dimensions
    __del__ = lambda self: None

    def width(self):
        """
        width(Dimensions self) -> double


        Returns the width.

        Returns the width attribute as a double.

        """
        return _libsbml.Dimensions_width(self)


    def height(self):
        """
        height(Dimensions self) -> double


        Returns the height.

        Returns the height attribute as a double.

        """
        return _libsbml.Dimensions_height(self)


    def depth(self):
        """
        depth(Dimensions self) -> double


        Returns the depth.

        Returns the depth attribute as a double.

        """
        return _libsbml.Dimensions_depth(self)


    def getWidth(self):
        """
        getWidth(Dimensions self) -> double


        Returns the width.

        Returns the width attribute as a double.

        """
        return _libsbml.Dimensions_getWidth(self)


    def getHeight(self):
        """
        getHeight(Dimensions self) -> double


        Returns the height.

        Returns the height attribute as a double.

        """
        return _libsbml.Dimensions_getHeight(self)


    def getDepth(self):
        """
        getDepth(Dimensions self) -> double


        Returns the depth.

        Returns the depth attribute as a double.

        """
        return _libsbml.Dimensions_getDepth(self)


    def setWidth(self, w):
        """
        setWidth(Dimensions self, double w)


        Sets the width to the given value.

        Parameter 'w' is the width to use.

        """
        return _libsbml.Dimensions_setWidth(self, w)


    def setHeight(self, h):
        """
        setHeight(Dimensions self, double h)


        Sets the height to the given value.

        Parameter 'h' is the height to use.

        """
        return _libsbml.Dimensions_setHeight(self, h)


    def setDepth(self, d):
        """
        setDepth(Dimensions self, double d)


        Sets the depth to the given value.  This will set the depth to be
        'explicitly set'.

        Parameter 'd' is the depth to use.

        """
        return _libsbml.Dimensions_setDepth(self, d)


    def setBounds(self, w, h, d=0.0):
        """
        setBounds(Dimensions self, double w, double h, double d=0.0)
        setBounds(Dimensions self, double w, double h)


        Sets all sizes of the Dimensions object to the given values. Using
        this function will set the depth to be 'explicitly set', even if the
        default is used.

        Parameter 'w' is the width to use. Parameter 'h' is the height to use.
        Parameter 'd' is the depth to use (defaults to 0.0).

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        return _libsbml.Dimensions_setBounds(self, w, h, d)


    def getDExplicitlySet(self):
        """
        getDExplicitlySet(Dimensions self) -> bool


        Checks whether the depth has been explicitly set.

        Returns a boolean value indicating whether the depth attribute  has
        been set explicitly or not.

        """
        return _libsbml.Dimensions_getDExplicitlySet(self)


    def initDefaults(self):
        """
        initDefaults(Dimensions self)


        Sets the depth to 0.0.  This will set the depth to be 'explicitly
        set'.

        """
        return _libsbml.Dimensions_initDefaults(self)


    def getId(self):
        """
        getId(Dimensions self) -> string


        Returns the value of the 'id' attribute of this Dimensions.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns the id of this Dimensions.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is now recommended to use the
        getIdAttribute() function instead.

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.Dimensions_getId(self)


    def isSetId(self):
        """
        isSetId(Dimensions self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        Dimensions's 'id' attribute has been set.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns 'True' if the 'id' attribute of this SBML object is set,
        'False' otherwise.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is recommended that callers use
        isSetIdAttribute() instead.

        See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(),
        isSetIdAttribute().

        """
        return _libsbml.Dimensions_isSetId(self)


    def setId(self, sid):
        """
        setId(Dimensions self, string sid) -> int


        Sets the value of the 'id' attribute of this Dimensions.

        The string 'sid' is copied.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Parameter 'sid' is the string to use as the identifier of this object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.Dimensions_setId(self, sid)


    def unsetId(self):
        """
        unsetId(Dimensions self) -> int


        Unsets the value of the 'id' attribute of this Dimensions.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.Dimensions_unsetId(self)


    def getElementName(self):
        """
        getElementName(Dimensions self) -> string


        Returns the XML element name of this SBML object.

        Returns the string of the name of this element.

        """
        return _libsbml.Dimensions_getElementName(self)


    def clone(self):
        """
        clone(Dimensions self) -> Dimensions


        Creates and returns a deep copy of this Dimensions.

        Returns a (deep) copy of this Dimensions object.

        """
        return _libsbml.Dimensions_clone(self)


    def getTypeCode(self):
        """
        getTypeCode(Dimensions self) -> int


        Returns the libSBML type code of this object instance.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_LAYOUT_DIMENSIONS.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.Dimensions_getTypeCode(self)


    def toXML(self):
        """
        toXML(Dimensions self) -> XMLNode


        Creates an XMLNode object from this.

        """
        return _libsbml.Dimensions_toXML(self)

Dimensions_swigregister = _libsbml.Dimensions_swigregister
Dimensions_swigregister(Dimensions)

class BoundingBox(SBase):
    """

    [SBML 'layout' package]

    A bounding box for an item in a diagram.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BoundingBox, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, BoundingBox, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(BoundingBox self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> BoundingBox
        __init__(BoundingBox self, unsigned int level, unsigned int version) -> BoundingBox
        __init__(BoundingBox self, unsigned int level) -> BoundingBox
        __init__(BoundingBox self) -> BoundingBox
        __init__(BoundingBox self, LayoutPkgNamespaces layoutns) -> BoundingBox
        __init__(BoundingBox self, BoundingBox orig) -> BoundingBox
        __init__(BoundingBox self, LayoutPkgNamespaces layoutns, string id) -> BoundingBox
        __init__(BoundingBox self, LayoutPkgNamespaces layoutns, string id, double x, double y, double width, double height) -> BoundingBox
        __init__(BoundingBox self, LayoutPkgNamespaces layoutns, string id, double x, double y, double z, double width, double height, double depth) -> BoundingBox
        __init__(BoundingBox self, LayoutPkgNamespaces layoutns, string id, Point p, Dimensions d) -> BoundingBox
        __init__(BoundingBox self, XMLNode node, unsigned int l2version=4) -> BoundingBox
        __init__(BoundingBox self, XMLNode node) -> BoundingBox


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            BoundingBox(LayoutPkgNamespaces layoutns, string id, double
        x, double y, double z, double width, double height, double depth)

        Constructor which sets the id, the coordinates and the dimensions to
        the given 3D values.

        (FOR BACKWARD COMPATIBILITY)

        ______________________________________________________________________
        Method variant with the following signature:

            BoundingBox(LayoutPkgNamespaces layoutns, string id, Point p,
        Dimensions d)

        Constructor which sets the id, the coordinates and the dimensions to
        the given values.

        (FOR BACKWARD COMPATIBILITY)

        ______________________________________________________________________
        Method variant with the following signature:

            BoundingBox(BoundingBox orig)

        Copy constructor.

        Parameter 'orig' is the instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            BoundingBox(LayoutPkgNamespaces layoutns, string id)

        Constructor.  Set position and dimensions to (0.0,0.0,0.0) and the id
        to a copy of the given string.

        (FOR BACKWARD COMPATIBILITY)

        ______________________________________________________________________
        Method variant with the following signature:

            BoundingBox(LayoutPkgNamespaces layoutns, string id, double
        x, double y, double width, double height)

        Constructor which sets the id, the coordinates and the dimensions to
        the given 2D values.

        (FOR BACKWARD COMPATIBILITY)

        ______________________________________________________________________
        Method variant with the following signature:

            BoundingBox(XMLNode node, long l2version=4)

        Creates a new BoundingBox from the given XMLNode

        (FOR BACKWARD COMPATIBILITY)

        ______________________________________________________________________
        Method variant with the following signature:

            BoundingBox(long level      =
        LayoutExtension.getDefaultLevel(), long version    =
        LayoutExtension.getDefaultVersion(), long pkgVersion =
        LayoutExtension.getDefaultPackageVersion())

        Default Constructor.  Set position and dimensions to (0.0,0.0,0.0) and
        the id to an empty string.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            BoundingBox(LayoutPkgNamespaces layoutns)

        Creates a new BoundingBox object with the given LayoutPkgNamespaces
        object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'layoutns' is the LayoutPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_BoundingBox(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_BoundingBox
    __del__ = lambda self: None

    def getId(self):
        """
        getId(BoundingBox self) -> string


        Returns the value of the 'id' attribute of this BoundingBox.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns the id of this BoundingBox.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is now recommended to use the
        getIdAttribute() function instead.

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.BoundingBox_getId(self)


    def isSetId(self):
        """
        isSetId(BoundingBox self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        BoundingBox's 'id' attribute has been set.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns 'True' if the 'id' attribute of this SBML object is set,
        'False' otherwise.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is recommended that callers use
        isSetIdAttribute() instead.

        See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(),
        isSetIdAttribute().

        """
        return _libsbml.BoundingBox_isSetId(self)


    def setId(self, sid):
        """
        setId(BoundingBox self, string sid) -> int


        Sets the value of the 'id' attribute of this BoundingBox.

        The string 'sid' is copied.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Parameter 'sid' is the string to use as the identifier of this object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.BoundingBox_setId(self, sid)


    def unsetId(self):
        """
        unsetId(BoundingBox self) -> int


        Unsets the value of the 'id' attribute of this BoundingBox.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.BoundingBox_unsetId(self)


    def getPosition(self):
        """
        getPosition(BoundingBox self) -> Point


        Returns the position of the BoundingBox as  reference to a Point
        object.

        Returns the Point representing the position.

        """
        return _libsbml.BoundingBox_getPosition(self)


    def getDimensions(self):
        """
        getDimensions(BoundingBox self) -> Dimensions


        Returns the dimensions of the BoundingBox as  reference to a
        Dimensions object.

        Returns the Dimensions representing the dimensions.

        """
        return _libsbml.BoundingBox_getDimensions(self)


    def setPosition(self, p):
        """
        setPosition(BoundingBox self, Point p)


        Sets the position to a copy of the Point object given.

        Parameter 'p' is the Point to use as the position.

        """
        return _libsbml.BoundingBox_setPosition(self, p)


    def setDimensions(self, d):
        """
        setDimensions(BoundingBox self, Dimensions d)


        Sets the dimensions to a copy of the Dimensions object given.

        Parameter 'd' is the Dimensions to use.

        """
        return _libsbml.BoundingBox_setDimensions(self, d)


    def getDimensionsExplicitlySet(self):
        """
        getDimensionsExplicitlySet(BoundingBox self) -> bool


        Return 'True' or 'False' based on whether Dimensions have been set.

        Returns 'True' if the Dimensions were set explicitly, 'False'
        otherwise.

        """
        return _libsbml.BoundingBox_getDimensionsExplicitlySet(self)


    def getPositionExplicitlySet(self):
        """
        getPositionExplicitlySet(BoundingBox self) -> bool


        Return 'True' or 'False' based on whether Position has been set.

        Returns 'True' if the Position was set explicitly, 'False' otherwise.

        """
        return _libsbml.BoundingBox_getPositionExplicitlySet(self)


    def initDefaults(self):
        """
        initDefaults(BoundingBox self)


        Does nothing since there are no defaults for a BoundingBox.

        """
        return _libsbml.BoundingBox_initDefaults(self)


    def getX(self):
        """
        getX(BoundingBox self) -> double


        Get the x offset of the bounding box.

        Returns the double value of the x offset.

        """
        return _libsbml.BoundingBox_getX(self)


    def getY(self):
        """
        getY(BoundingBox self) -> double


        Get the y offset of the bounding box.

        Returns the double value of the y offset.

        """
        return _libsbml.BoundingBox_getY(self)


    def getZ(self):
        """
        getZ(BoundingBox self) -> double


        Get the z offset of the bounding box.

        Returns the double value of the z offset.

        """
        return _libsbml.BoundingBox_getZ(self)


    def getWidth(self):
        """
        getWidth(BoundingBox self) -> double


        Get the width of the bounding box.

        Returns the double value of the width.

        """
        return _libsbml.BoundingBox_getWidth(self)


    def getHeight(self):
        """
        getHeight(BoundingBox self) -> double


        Get the height of the bounding box.

        Returns the double value of the height.

        """
        return _libsbml.BoundingBox_getHeight(self)


    def getDepth(self):
        """
        getDepth(BoundingBox self) -> double


        Get the depth of the bounding box.

        Returns the double value of the depth.

        """
        return _libsbml.BoundingBox_getDepth(self)


    def setX(self, x):
        """
        setX(BoundingBox self, double x)


        Set x offset of the bounding box.

        Parameter 'x' is the double value to set the x offset to.

        """
        return _libsbml.BoundingBox_setX(self, x)


    def setY(self, y):
        """
        setY(BoundingBox self, double y)


        Set y offset of the bounding box.

        Parameter 'y' is the double value to set the y offset to.

        """
        return _libsbml.BoundingBox_setY(self, y)


    def setZ(self, z):
        """
        setZ(BoundingBox self, double z)


        Set z offset of the bounding box.

        Parameter 'z' is the double value to set the z offset to.

        """
        return _libsbml.BoundingBox_setZ(self, z)


    def setWidth(self, width):
        """
        setWidth(BoundingBox self, double width)


        Set width of the bounding box.

        Parameter 'width' is the double value to set the width to.

        """
        return _libsbml.BoundingBox_setWidth(self, width)


    def setHeight(self, height):
        """
        setHeight(BoundingBox self, double height)


        Set height of the bounding box.

        Parameter 'height' is the double value to set the height to.

        """
        return _libsbml.BoundingBox_setHeight(self, height)


    def setDepth(self, depth):
        """
        setDepth(BoundingBox self, double depth)


        Set depth of the bounding box.

        Parameter 'depth' is the double value to set the depth to.

        """
        return _libsbml.BoundingBox_setDepth(self, depth)


    def getElementName(self):
        """
        getElementName(BoundingBox self) -> string


        Returns the XML element name of this SBML object.

        Returns the string of the name of this element.

        """
        return _libsbml.BoundingBox_getElementName(self)


    def clone(self):
        """
        clone(BoundingBox self) -> BoundingBox


        Creates and returns a deep copy of this BoundingBox.

        Returns a (deep) copy of this BoundingBox.

        """
        return _libsbml.BoundingBox_clone(self)


    def getTypeCode(self):
        """
        getTypeCode(BoundingBox self) -> int


        Returns the libSBML type code of this object instance.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_LAYOUT_BOUNDINGBOX.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.BoundingBox_getTypeCode(self)


    def toXML(self):
        """
        toXML(BoundingBox self) -> XMLNode


        Creates an XMLNode object from this.

        Returns an XMLNode representing this object.

        """
        return _libsbml.BoundingBox_toXML(self)


    def connectToChild(self):
        """connectToChild(BoundingBox self)"""
        return _libsbml.BoundingBox_connectToChild(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(BoundingBox self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.BoundingBox_enablePackageInternal(self, pkgURI, pkgPrefix, flag)

BoundingBox_swigregister = _libsbml.BoundingBox_swigregister
BoundingBox_swigregister(BoundingBox)

class GraphicalObject(SBase):
    """

    [SBML 'layout' package]

    Base class of objects that store layouts.

    All the more specific layout elements (CompartmentGlyph, GeneralGlyph,
    SpeciesGlyph, ReactionGlyph, ReferenceGlyph, TextGlyph, and
    SpeciesReferenceGlyph) are derived from the class GraphicalObject.
    Each object of class GraphicalObject has a mandatory BoundingBox,
    which specifies the position and the size of the object.  While
    GraphicalObject is the base class for most elements in the "layout"
    package, it is not an abstract class. It can be instantiated when used
    in the listOfAdditionalGraphicalObjects to describe additional
    elements and relationships. Since it only describes a BoundingBox,
    programs are encouraged to add Annotation objects that describe
    program-specific graphical information.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GraphicalObject, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, GraphicalObject, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(GraphicalObject self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> GraphicalObject
        __init__(GraphicalObject self, unsigned int level, unsigned int version) -> GraphicalObject
        __init__(GraphicalObject self, unsigned int level) -> GraphicalObject
        __init__(GraphicalObject self) -> GraphicalObject
        __init__(GraphicalObject self, LayoutPkgNamespaces layoutns) -> GraphicalObject
        __init__(GraphicalObject self, LayoutPkgNamespaces layoutns, string id) -> GraphicalObject
        __init__(GraphicalObject self, LayoutPkgNamespaces layoutns, string id, double x, double y, double w, double h) -> GraphicalObject
        __init__(GraphicalObject self, LayoutPkgNamespaces layoutns, string id, double x, double y, double z, double w, double h, double d) -> GraphicalObject
        __init__(GraphicalObject self, LayoutPkgNamespaces layoutns, string id, Point p, Dimensions d) -> GraphicalObject
        __init__(GraphicalObject self, LayoutPkgNamespaces layoutns, string id, BoundingBox bb) -> GraphicalObject
        __init__(GraphicalObject self, XMLNode node, unsigned int l2version=4) -> GraphicalObject
        __init__(GraphicalObject self, XMLNode node) -> GraphicalObject
        __init__(GraphicalObject self, GraphicalObject source) -> GraphicalObject


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            GraphicalObject(LayoutPkgNamespaces layoutns, string id,
        Point p, Dimensions d)

        Creates a new GraphicalObject with the given 'id' and 3D coordinates
        for the bounding box.

        (FOR BACKWARD COMPATIBILITY)

        ______________________________________________________________________
        Method variant with the following signature:

            GraphicalObject(GraphicalObject source)

        Copy constructor.

        Parameter 'source' is the instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            GraphicalObject(LayoutPkgNamespaces layoutns, string id,
        double x, double y, double z, double w, double h, double d)

        Creates a new GraphicalObject with the given 'id' and 3D coordinates
        for the bounding box.

        (FOR BACKWARD COMPATIBILITY)

        ______________________________________________________________________
        Method variant with the following signature:

            GraphicalObject(XMLNode node, long l2version=4)

        Creates a new GraphicalObject from the given XMLNode

        (FOR BACKWARD COMPATIBILITY)

        ______________________________________________________________________
        Method variant with the following signature:

            GraphicalObject(LayoutPkgNamespaces layoutns, string id,
        double x, double y, double w, double h)

        Creates a new GraphicalObject with the given 'id' and 2D coordinates
        for the bounding box.

        (FOR BACKWARD COMPATIBILITY)

        ______________________________________________________________________
        Method variant with the following signature:

            GraphicalObject(long level      =
        LayoutExtension.getDefaultLevel(), long version    =
        LayoutExtension.getDefaultVersion(), long pkgVersion =
        LayoutExtension.getDefaultPackageVersion())

        Creates a new GraphicalObject.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            GraphicalObject(LayoutPkgNamespaces layoutns, string id,
        BoundingBox bb)

        Creates a new GraphicalObject with the given 'id' and 3D coordinates
        for the bounding box.

        (FOR BACKWARD COMPATIBILITY)

        ______________________________________________________________________
        Method variant with the following signature:

            GraphicalObject(LayoutPkgNamespaces layoutns)

        Creates a new GraphicalObject with the given LayoutPkgNamespaces

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'layoutns' is the LayoutPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        ______________________________________________________________________
        Method variant with the following signature:

            GraphicalObject(LayoutPkgNamespaces layoutns, string id)

        Creates a new GraphicalObject with the given 'id'.

        (FOR BACKWARD COMPATIBILITY)

        """
        this = _libsbml.new_GraphicalObject(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_GraphicalObject
    __del__ = lambda self: None

    def initDefaults(self):
        """
        initDefaults(GraphicalObject self)


        Does nothing. No defaults are defined for GraphicalObject.

        """
        return _libsbml.GraphicalObject_initDefaults(self)


    def renameMetaIdRefs(self, oldid, newid):
        """
        renameMetaIdRefs(GraphicalObject self, string oldid, string newid)


        Renames all the 'MetaIdRef' attributes on this element.

        This method works by looking at all meta-attribute values, comparing
        the identifiers to the value of 'oldid'.  If any matches are found,
        the matching identifiers are replaced with 'newid'.  The method does
        not descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.GraphicalObject_renameMetaIdRefs(self, oldid, newid)


    def getId(self):
        """
        getId(GraphicalObject self) -> string


        Returns the value of the 'id' attribute of this GraphicalObject.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns the id of this GraphicalObject.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is now recommended to use the
        getIdAttribute() function instead.

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.GraphicalObject_getId(self)


    def isSetId(self):
        """
        isSetId(GraphicalObject self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        GraphicalObject's 'id' attribute has been set.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns 'True' if the 'id' attribute of this SBML object is set,
        'False' otherwise.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is recommended that callers use
        isSetIdAttribute() instead.

        See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(),
        isSetIdAttribute().

        """
        return _libsbml.GraphicalObject_isSetId(self)


    def setId(self, sid):
        """
        setId(GraphicalObject self, string sid) -> int


        Sets the value of the 'id' attribute of this GraphicalObject.

        The string 'sid' is copied.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Parameter 'sid' is the string to use as the identifier of this object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.GraphicalObject_setId(self, sid)


    def unsetId(self):
        """
        unsetId(GraphicalObject self) -> int


        Unsets the value of the 'id' attribute of this GraphicalObject.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.GraphicalObject_unsetId(self)


    def getMetaIdRef(self):
        """
        getMetaIdRef(GraphicalObject self) -> string


        Returns the value of the 'metaidRef' attribute of this
        GraphicalObject.

        """
        return _libsbml.GraphicalObject_getMetaIdRef(self)


    def isSetMetaIdRef(self):
        """
        isSetMetaIdRef(GraphicalObject self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        GraphicalObject's 'metaidRef' attribute has been set.

        """
        return _libsbml.GraphicalObject_isSetMetaIdRef(self)


    def setMetaIdRef(self, metaid):
        """
        setMetaIdRef(GraphicalObject self, string metaid) -> int


        Sets the value of the 'metaidRef' attribute of this GraphicalObject.

        """
        return _libsbml.GraphicalObject_setMetaIdRef(self, metaid)


    def unsetMetaIdRef(self):
        """
        unsetMetaIdRef(GraphicalObject self) -> int


        Unsets the value of the 'metaidRef' attribute of this GraphicalObject.

        """
        return _libsbml.GraphicalObject_unsetMetaIdRef(self)


    def setBoundingBox(self, bb):
        """
        setBoundingBox(GraphicalObject self, BoundingBox bb)


        Sets the boundingbox for the GraphicalObject.

        """
        return _libsbml.GraphicalObject_setBoundingBox(self, bb)


    def getBoundingBox(self):
        """
        getBoundingBox(GraphicalObject self) -> BoundingBox


        Returns the bounding box for the GraphicalObject.

        """
        return _libsbml.GraphicalObject_getBoundingBox(self)


    def getBoundingBoxExplicitlySet(self):
        """
        getBoundingBoxExplicitlySet(GraphicalObject self) -> bool




        """
        return _libsbml.GraphicalObject_getBoundingBoxExplicitlySet(self)


    def getElementName(self):
        """
        getElementName(GraphicalObject self) -> string


        Returns the XML element name of this SBML object.

        Returns the string of the name of this element.

        """
        return _libsbml.GraphicalObject_getElementName(self)


    def clone(self):
        """
        clone(GraphicalObject self) -> GraphicalObject


        Creates and returns a deep copy of this GraphicalObject.

        Returns a (deep) copy of this GraphicalObject.

        """
        return _libsbml.GraphicalObject_clone(self)


    def getTypeCode(self):
        """
        getTypeCode(GraphicalObject self) -> int


        Returns the libSBML type code of this object instance.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object:
        SBML_LAYOUT_GRAPHICALOBJECT.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.GraphicalObject_getTypeCode(self)


    def toXML(self):
        """
        toXML(GraphicalObject self) -> XMLNode


        Creates an XMLNode object from this.

        """
        return _libsbml.GraphicalObject_toXML(self)


    def connectToChild(self):
        """connectToChild(GraphicalObject self)"""
        return _libsbml.GraphicalObject_connectToChild(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(GraphicalObject self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.GraphicalObject_enablePackageInternal(self, pkgURI, pkgPrefix, flag)

GraphicalObject_swigregister = _libsbml.GraphicalObject_swigregister
GraphicalObject_swigregister(GraphicalObject)

class ListOfGraphicalObjects(ListOf):
    """

    [SBML 'layout' package]

    A list of GraphicalObject objects.

    The ListOfGraphicalObjects class in libSBML actually represents the
    ListOfAdditionalGraphicalObjects class in the "layout" package, and
    is a container for the additional GraphicalObject elements of a
    Layout.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    See also GraphicalObject.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfGraphicalObjects, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfGraphicalObjects, name)
    __repr__ = _swig_repr

    def clone(self):
        """
        clone(ListOfGraphicalObjects self) -> ListOfGraphicalObjects


        Creates and returns a deep copy of this ListOfGraphicalObjects.

        Returns a (deep) copy of this ListOfGraphicalObjects.

        """
        return _libsbml.ListOfGraphicalObjects_clone(self)


    def __init__(self, *args):
        """
        __init__(ListOfGraphicalObjects self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ListOfGraphicalObjects
        __init__(ListOfGraphicalObjects self, unsigned int level, unsigned int version) -> ListOfGraphicalObjects
        __init__(ListOfGraphicalObjects self, unsigned int level) -> ListOfGraphicalObjects
        __init__(ListOfGraphicalObjects self) -> ListOfGraphicalObjects
        __init__(ListOfGraphicalObjects self, LayoutPkgNamespaces layoutns) -> ListOfGraphicalObjects


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfGraphicalObjects(LayoutPkgNamespaces layoutns)

        Constructor.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'layoutns' is the LayoutPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfGraphicalObjects(long level      =
        LayoutExtension.getDefaultLevel(), long version    =
        LayoutExtension.getDefaultVersion(), long pkgVersion =
        LayoutExtension.getDefaultPackageVersion())

        Constructor.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        this = _libsbml.new_ListOfGraphicalObjects(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfGraphicalObjects self) -> int


        Returns the libSBML type code for the SBML objects contained in this
        ListOf object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for objects contained in this list:
        SBML_LAYOUT_GRAPHICALOBJECT (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfGraphicalObjects_getItemTypeCode(self)


    def getElementName(self):
        """
        getElementName(ListOfGraphicalObjects self) -> string


        Returns the XML element name of this SBML object.

        Returns the string of the name of this element.

        """
        return _libsbml.ListOfGraphicalObjects_getElementName(self)


    def setElementName(self, elementName):
        """
        setElementName(ListOfGraphicalObjects self, string elementName)


        Internal implementation method.

        """
        return _libsbml.ListOfGraphicalObjects_setElementName(self, elementName)


    def get(self, *args):
        """
        get(ListOfGraphicalObjects self, unsigned int n) -> GraphicalObject
        get(ListOfGraphicalObjects self, unsigned int n) -> GraphicalObject
        get(ListOfGraphicalObjects self, string sid) -> GraphicalObject
        get(ListOfGraphicalObjects self, string sid) -> GraphicalObject


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a GraphicalObject from the ListOfGraphicalObjects.

        Parameter 'n' is the index number of the GraphicalObject to get.

        Returns the nth GraphicalObject in this ListOfGraphicalObjects. If the
        index 'n' is invalid, 'None' is returned.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a GraphicalObject from the ListOfGraphicalObjects based on its
        identifier.

        Parameter 'sid' is a string representing the identifier  of the
        GraphicalObject to get.

        Returns GraphicalObject in this ListOfGraphicalObjects with the given
        'sid' or 'None' if no such GraphicalObject exists.

        See also get(), size().

        """
        return _libsbml.ListOfGraphicalObjects_get(self, *args)


    def remove(self, *args):
        """
        remove(ListOfGraphicalObjects self, unsigned int n) -> GraphicalObject
        remove(ListOfGraphicalObjects self, string sid) -> GraphicalObject


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth item from this ListOfGraphicalObjects items and
        returns a pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the item to remove.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes item in this ListOfGraphicalObjects 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 'sid', then
        'None' is returned.

        Parameter 'sid' is the identifier of the item to remove.

        Returns the item removed.  As mentioned above, the caller owns the
        returned item.

        """
        return _libsbml.ListOfGraphicalObjects_remove(self, *args)


    def toXML(self):
        """
        toXML(ListOfGraphicalObjects self) -> XMLNode


        Creates an XMLNode object from this.

        """
        return _libsbml.ListOfGraphicalObjects_toXML(self)

    __swig_destroy__ = _libsbml.delete_ListOfGraphicalObjects
    __del__ = lambda self: None
ListOfGraphicalObjects_swigregister = _libsbml.ListOfGraphicalObjects_swigregister
ListOfGraphicalObjects_swigregister(ListOfGraphicalObjects)

class CompartmentGlyph(GraphicalObject):
    """

    [SBML 'layout' package]

    A glyph for an SBML compartment.

    """

    __swig_setmethods__ = {}
    for _s in [GraphicalObject]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CompartmentGlyph, name, value)
    __swig_getmethods__ = {}
    for _s in [GraphicalObject]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CompartmentGlyph, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(CompartmentGlyph self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> CompartmentGlyph
        __init__(CompartmentGlyph self, unsigned int level, unsigned int version) -> CompartmentGlyph
        __init__(CompartmentGlyph self, unsigned int level) -> CompartmentGlyph
        __init__(CompartmentGlyph self) -> CompartmentGlyph
        __init__(CompartmentGlyph self, LayoutPkgNamespaces layoutns) -> CompartmentGlyph
        __init__(CompartmentGlyph self, LayoutPkgNamespaces layoutns, string id) -> CompartmentGlyph
        __init__(CompartmentGlyph self, LayoutPkgNamespaces layoutns, string id, string compartmentId) -> CompartmentGlyph
        __init__(CompartmentGlyph self, XMLNode node, unsigned int l2version=4) -> CompartmentGlyph
        __init__(CompartmentGlyph self, XMLNode node) -> CompartmentGlyph
        __init__(CompartmentGlyph self, CompartmentGlyph source) -> CompartmentGlyph


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            CompartmentGlyph(LayoutPkgNamespaces layoutns, string id,
        string compartmentId)

        Constructor which creates a new CompartmentGlyph.  Id and associated
        compartment id are set to copies of the values given as arguments.

        (FOR BACKWARD COMPATIBILITY)

        ______________________________________________________________________
        Method variant with the following signature:

            CompartmentGlyph(XMLNode node, long l2version=4)

        Creates a new CompartmentGlyph from the given XMLNode

        (FOR BACKWARD COMPATIBILITY)

        ______________________________________________________________________
        Method variant with the following signature:

            CompartmentGlyph(CompartmentGlyph source)

        Copy constructor.

        Parameter 'source' is the instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            CompartmentGlyph(long level      =
        LayoutExtension.getDefaultLevel(), long version    =
        LayoutExtension.getDefaultVersion(), long pkgVersion =
        LayoutExtension.getDefaultPackageVersion())

        Default Constructor which creates a new CompartmentGlyph.  Id and
        associated compartment id are unset.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            CompartmentGlyph(LayoutPkgNamespaces layoutns)

        Constructor.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'layoutns' is the LayoutPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        ______________________________________________________________________
        Method variant with the following signature:

            CompartmentGlyph(LayoutPkgNamespaces layoutns, string id)

        Constructor which creates a new CompartmentGlyph with the given 'id'.

        (FOR BACKWARD COMPATIBILITY)

        """
        this = _libsbml.new_CompartmentGlyph(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_CompartmentGlyph
    __del__ = lambda self: None

    def getCompartmentId(self):
        """
        getCompartmentId(CompartmentGlyph self) -> string


        Returns the id of the associated compartment.

        Returns the value of the 'compartment' attribute.

        """
        return _libsbml.CompartmentGlyph_getCompartmentId(self)


    def setCompartmentId(self, id):
        """
        setCompartmentId(CompartmentGlyph self, string id) -> int


        Sets the id of the associated compartment.

        Parameter 'id' is the identifier of a Compartment object defined
        elsewhere in this Model.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.CompartmentGlyph_setCompartmentId(self, id)


    def isSetCompartmentId(self):
        """
        isSetCompartmentId(CompartmentGlyph self) -> bool


        Returns 'True' if the id of the associated compartment is not the
        empty string.

        Returns 'True' if the 'compartment' attribute of this CompartmentGlyph
        is set, 'False' otherwise.

        """
        return _libsbml.CompartmentGlyph_isSetCompartmentId(self)


    def getOrder(self):
        """
        getOrder(CompartmentGlyph self) -> double


        Returns the compartment order.

        Returns the value of the 'order' attribute.

        """
        return _libsbml.CompartmentGlyph_getOrder(self)


    def setOrder(self, order):
        """
        setOrder(CompartmentGlyph self, double order) -> int


        Sets the compartment order.

        Parameter 'order' is the value to use for the 'order' attribute.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.CompartmentGlyph_setOrder(self, order)


    def unsetOrder(self):
        """
        unsetOrder(CompartmentGlyph self) -> int


        Unsets the compartment order.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.CompartmentGlyph_unsetOrder(self)


    def isSetOrder(self):
        """
        isSetOrder(CompartmentGlyph self) -> bool


        Returns 'True' if the compartment order has been set.

        Returns 'True' if the 'order' attribute of this CompartmentGlyph is
        set, 'False' otherwise.

        """
        return _libsbml.CompartmentGlyph_isSetOrder(self)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(CompartmentGlyph self, string oldid, string newid)


        Replaces all uses of a given 'SIdRef' type attribute value with
        another value.

        In SBML, object identifiers are of a data type called SId. In SBML
        Level 3, an explicit data type called SIdRef was introduced for
        attribute values that refer to SId values; in previous Levels of SBML,
        this data type did not exist and attributes were simply described to
        as 'referring to an identifier', but the effective data type was the
        same as SIdRef in Level 3.  These and other methods of libSBML refer
        to the type SIdRef for all Levels of SBML, even if the corresponding
        SBML specification did not explicitly name the data type.

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas in MathML content, comparing the referenced
        identifiers to the value of 'oldid'.  If any matches are found, the
        matching values are replaced with 'newid'.  The method does not
        descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.CompartmentGlyph_renameSIdRefs(self, oldid, newid)


    def initDefaults(self):
        """
        initDefaults(CompartmentGlyph self)


        Calls initDefaults from GraphicalObject.

        """
        return _libsbml.CompartmentGlyph_initDefaults(self)


    def getElementName(self):
        """
        getElementName(CompartmentGlyph self) -> string


        Returns the XML element name of this SBML object.

        Returns the string of the name of this element.

        """
        return _libsbml.CompartmentGlyph_getElementName(self)


    def clone(self):
        """
        clone(CompartmentGlyph self) -> CompartmentGlyph


        Creates and returns a deep copy of this CompartmentGlyph.

        Returns a (deep) copy of this CompartmentGlyph.

        """
        return _libsbml.CompartmentGlyph_clone(self)


    def getTypeCode(self):
        """
        getTypeCode(CompartmentGlyph self) -> int


        Returns the libSBML type code of this object instance.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object:
        SBML_LAYOUT_COMPARTMENTGLYPH

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.CompartmentGlyph_getTypeCode(self)


    def toXML(self):
        """
        toXML(CompartmentGlyph self) -> XMLNode


        Creates an XMLNode object from this CompartmentGlyph.

        Returns an XMLNode object based off of the information in this
        CompartmentGlyph.

        """
        return _libsbml.CompartmentGlyph_toXML(self)

CompartmentGlyph_swigregister = _libsbml.CompartmentGlyph_swigregister
CompartmentGlyph_swigregister(CompartmentGlyph)

class LineSegment(SBase):
    """

    [SBML 'layout' package]

    Representation of a line.

    The LineSegment class consists of the mandatory attribute xsi:type and
    two child elements of type Point. One is called 'start' and represents
    the starting point of the line, the other is called 'end' and
    represents the endpoint of the line.  The LineSegment class is also
    the base class for CubicBezier, which represent curved lines instead
    of straight ones.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LineSegment, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, LineSegment, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(LineSegment self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> LineSegment
        __init__(LineSegment self, unsigned int level, unsigned int version) -> LineSegment
        __init__(LineSegment self, unsigned int level) -> LineSegment
        __init__(LineSegment self) -> LineSegment
        __init__(LineSegment self, LayoutPkgNamespaces layoutns) -> LineSegment
        __init__(LineSegment self, LayoutPkgNamespaces layoutns, double x1, double y1, double x2, double y2) -> LineSegment
        __init__(LineSegment self, LineSegment orig) -> LineSegment
        __init__(LineSegment self, LayoutPkgNamespaces layoutns, double x1, double y1, double z1, double x2, double y2, double z2) -> LineSegment
        __init__(LineSegment self, LayoutPkgNamespaces layoutns, Point start, Point end) -> LineSegment
        __init__(LineSegment self, XMLNode node, unsigned int l2version=4) -> LineSegment
        __init__(LineSegment self, XMLNode node) -> LineSegment


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            LineSegment(LayoutPkgNamespaces layoutns, double x1, double
        y1, double x2, double y2)

        Creates a new line segment with the given 2D coordinates.

        ______________________________________________________________________
        Method variant with the following signature:

            LineSegment(XMLNode node, long l2version=4)

        Creates a new LineSegment from the given XMLNode

        ______________________________________________________________________
        Method variant with the following signature:

            LineSegment(LayoutPkgNamespaces layoutns, Point start, Point
        end)

        Creates a new line segment with the two given points.

        ______________________________________________________________________
        Method variant with the following signature:

            LineSegment(long level      =
        LayoutExtension.getDefaultLevel(), long version    =
        LayoutExtension.getDefaultVersion(), long pkgVersion =
        LayoutExtension.getDefaultPackageVersion())

        Creates a line segment with the given SBML level, version, and package
        version and both points set to (0.0,0.0,0.0)

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            LineSegment(LayoutPkgNamespaces layoutns)

        Creates a line segment with the LayoutPkgNamespaces and both points
        set to (0.0,0.0,0.0)

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'layoutns' is the LayoutPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        ______________________________________________________________________
        Method variant with the following signature:

            LineSegment(LayoutPkgNamespaces layoutns, double x1, double
        y1, double z1, double x2, double y2, double z2)

        Creates a new line segment with the given 3D coordinates.

        ______________________________________________________________________
        Method variant with the following signature:

            LineSegment(LineSegment orig)

        Copy constructor.

        Parameter 'orig' is the instance to copy.

        """
        this = _libsbml.new_LineSegment(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_LineSegment
    __del__ = lambda self: None

    def getStart(self):
        """
        getStart(LineSegment self) -> Point


        Returns the start point of the line.

        """
        return _libsbml.LineSegment_getStart(self)


    def setStart(self, *args):
        """
        setStart(LineSegment self, Point start)
        setStart(LineSegment self, double x, double y, double z=0.0)
        setStart(LineSegment self, double x, double y)


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            setStart(Point start)

        Initializes the start point with a copy of the given Point object.

        ______________________________________________________________________
        Method variant with the following signature:

            setStart(double x, double y, double z = 0.0)

        Initializes the start point with the given coordinates.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        return _libsbml.LineSegment_setStart(self, *args)


    def getEnd(self):
        """
        getEnd(LineSegment self) -> Point


        Returns the end point of the line.

        """
        return _libsbml.LineSegment_getEnd(self)


    def setEnd(self, *args):
        """
        setEnd(LineSegment self, Point end)
        setEnd(LineSegment self, double x, double y, double z=0.0)
        setEnd(LineSegment self, double x, double y)


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            setEnd(double x, double y, double z = 0.0)

        Initializes the end point with the given coordinates.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            setEnd(Point end)

        Initializes the end point with a copy of the given Point object.

        """
        return _libsbml.LineSegment_setEnd(self, *args)


    def getStartExplicitlySet(self):
        """
        getStartExplicitlySet(LineSegment self) -> bool


        Internal implementation method.

        """
        return _libsbml.LineSegment_getStartExplicitlySet(self)


    def getEndExplicitlySet(self):
        """
        getEndExplicitlySet(LineSegment self) -> bool


        Internal implementation method.

        """
        return _libsbml.LineSegment_getEndExplicitlySet(self)


    def initDefaults(self):
        """
        initDefaults(LineSegment self)


        Does nothing since no defaults are defined for LineSegment.

        """
        return _libsbml.LineSegment_initDefaults(self)


    def getElementName(self):
        """
        getElementName(LineSegment self) -> string


        Returns the XML element name of this SBML object.

        Returns the string of the name of this element.

        """
        return _libsbml.LineSegment_getElementName(self)


    def clone(self):
        """
        clone(LineSegment self) -> LineSegment


        Creates and returns a deep copy of this LineSegment.

        Returns a (deep) copy of this LineSegment.

        """
        return _libsbml.LineSegment_clone(self)


    def getTypeCode(self):
        """
        getTypeCode(LineSegment self) -> int


        Returns the libSBML type code of this object instance.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_LAYOUT_LINESEGMENT

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.LineSegment_getTypeCode(self)


    def toXML(self):
        """
        toXML(LineSegment self) -> XMLNode


        Creates an XMLNode object from this.

        """
        return _libsbml.LineSegment_toXML(self)


    def connectToChild(self):
        """connectToChild(LineSegment self)"""
        return _libsbml.LineSegment_connectToChild(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(LineSegment self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.LineSegment_enablePackageInternal(self, pkgURI, pkgPrefix, flag)

LineSegment_swigregister = _libsbml.LineSegment_swigregister
LineSegment_swigregister(LineSegment)

class CubicBezier(LineSegment):
    """

    [SBML 'layout' package]

    A Cubic B&eacute;zier smooth curve.

    In order to be able to represent smooth curves the "layout" package
    defines the class CubicBezier. It represents a Bezier curve, and is
    readily available in most graphics APIs.  The class CubicBezier is
    derived from LineSegment. It consists of four elements: the two
    inherited elements 'start' and 'end', which specify the starting point
    and the endpoint of the cubic bezier curve, and two elements
    'basePoint1' and 'basePoint2', which specify the two additional base
    points that are needed to describe a cubic bezier curve.

    """

    __swig_setmethods__ = {}
    for _s in [LineSegment]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CubicBezier, name, value)
    __swig_getmethods__ = {}
    for _s in [LineSegment]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CubicBezier, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(CubicBezier self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> CubicBezier
        __init__(CubicBezier self, unsigned int level, unsigned int version) -> CubicBezier
        __init__(CubicBezier self, unsigned int level) -> CubicBezier
        __init__(CubicBezier self) -> CubicBezier
        __init__(CubicBezier self, LayoutPkgNamespaces layoutns) -> CubicBezier
        __init__(CubicBezier self, LayoutPkgNamespaces layoutns, double x1, double y1, double x2, double y2) -> CubicBezier
        __init__(CubicBezier self, LayoutPkgNamespaces layoutns, double x1, double y1, double z1, double x2, double y2, double z2) -> CubicBezier
        __init__(CubicBezier self, CubicBezier orig) -> CubicBezier
        __init__(CubicBezier self, LayoutPkgNamespaces layoutns, Point start, Point end) -> CubicBezier
        __init__(CubicBezier self, LayoutPkgNamespaces layoutns, Point start, Point base1, Point base2, Point end) -> CubicBezier
        __init__(CubicBezier self, XMLNode node, unsigned int l2version=4) -> CubicBezier
        __init__(CubicBezier self, XMLNode node) -> CubicBezier


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            CubicBezier(CubicBezier orig)

        Copy constructor.

        (FOR BACKWARD COMPATIBILITY)

        ______________________________________________________________________
        Method variant with the following signature:

            CubicBezier(LayoutPkgNamespaces layoutns, double x1, double
        y1, double x2, double y2)

        Creates a CubicBezier with the given 2D coordinates and returns the
        pointer.

        (FOR BACKWARD COMPATIBILITY)

        ______________________________________________________________________
        Method variant with the following signature:

            CubicBezier(XMLNode node, long l2version=4)

        Creates a new Layout from the given XMLNode

        (FOR BACKWARD COMPATIBILITY)

        ______________________________________________________________________
        Method variant with the following signature:

            CubicBezier(LayoutPkgNamespaces layoutns, double x1, double
        y1, double z1, double x2, double y2, double z2)

        Creates a CubicBezier with the given 3D coordinates and returns the
        pointer.

        (FOR BACKWARD COMPATIBILITY)

        ______________________________________________________________________
        Method variant with the following signature:

            CubicBezier(long level      =
        LayoutExtension.getDefaultLevel(), long version    =
        LayoutExtension.getDefaultVersion(), long pkgVersion =
        LayoutExtension.getDefaultPackageVersion())

        Creates a CubicBezier and returns the pointer.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            CubicBezier(LayoutPkgNamespaces layoutns)

        Constructor.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'layoutns' is the LayoutPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        ______________________________________________________________________
        Method variant with the following signature:

            CubicBezier(LayoutPkgNamespaces layoutns, Point start, Point
        end)

        Creates a CubicBezier with the given points and returns the pointer.

        (FOR BACKWARD COMPATIBILITY)

        ______________________________________________________________________
        Method variant with the following signature:

            CubicBezier(LayoutPkgNamespaces layoutns, Point start, Point
        base1, Point base2, Point end)

        Creates a CubicBezier with the given points and returns the pointer.

        (FOR BACKWARD COMPATIBILITY)

        """
        this = _libsbml.new_CubicBezier(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_CubicBezier
    __del__ = lambda self: None

    def getBasePoint1(self):
        """
        getBasePoint1(CubicBezier self) -> Point


        Returns the first base point of the curve (the one closer to the
        starting point).

        Returns the Point child 'basePoint1'.  Will always return an actual
        object: if previously unset, the Point will exist, but have no set
        attributes nor children.

        """
        return _libsbml.CubicBezier_getBasePoint1(self)


    def setBasePoint1(self, *args):
        """
        setBasePoint1(CubicBezier self, Point p)
        setBasePoint1(CubicBezier self, double x, double y, double z=0.0)
        setBasePoint1(CubicBezier self, double x, double y)


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            setBasePoint1(double x, double y, double z = 0.0)

        Initializes first base point with the given coordinates.  It is
        impossible to create a Point with no 'z' attribute in this way; if no
        value is supplied, '0.0' will be used.

        Parameter 'x' is the value to use for the 'x' attribute of the
        basePoint1 Point. Parameter 'y' is the value to use for the 'y'
        attribute of the basePoint1 Point. Parameter 'z' is the value to use
        for the 'z' attribute of the basePoint1 Point.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            setBasePoint1(Point p)

        Initializes first base point with a copy of the given point.

        Parameter 'p' is the Point to use as 'basePoint1' (creates a copy).

        """
        return _libsbml.CubicBezier_setBasePoint1(self, *args)


    def getBasePoint2(self):
        """
        getBasePoint2(CubicBezier self) -> Point


        Returns the second base point of the curve (the one closer to the end
        point).

        Returns the Point child 'basePoint2'.  Will always return an actual
        object: if previously unset, the Point will exist, but have no set
        attributes nor children.

        """
        return _libsbml.CubicBezier_getBasePoint2(self)


    def setBasePoint2(self, *args):
        """
        setBasePoint2(CubicBezier self, Point p)
        setBasePoint2(CubicBezier self, double x, double y, double z=0.0)
        setBasePoint2(CubicBezier self, double x, double y)


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            setBasePoint2(double x, double y, double z = 0.0)

        Initializes second base point with the given coordinates.  It is
        impossible to create a Point with no 'z' attribute in this way; if no
        value is supplied, '0.0' will be used.

        Parameter 'x' is the value to use for the 'x' attribute of the
        basePoint2 Point. Parameter 'y' is the value to use for the 'y'
        attribute of the basePoint2 Point. Parameter 'z' is the value to use
        for the 'z' attribute of the basePoint2 Point.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            setBasePoint2(Point p)

        Initializes second base point with a copy of the given point.

        Parameter 'p' is the Point to use as 'basePoint2' (creates a copy).

        """
        return _libsbml.CubicBezier_setBasePoint2(self, *args)


    def getBasePt1ExplicitlySet(self):
        """
        getBasePt1ExplicitlySet(CubicBezier self) -> bool


        Internal implementation method.

        """
        return _libsbml.CubicBezier_getBasePt1ExplicitlySet(self)


    def getBasePt2ExplicitlySet(self):
        """
        getBasePt2ExplicitlySet(CubicBezier self) -> bool


        Internal implementation method.

        """
        return _libsbml.CubicBezier_getBasePt2ExplicitlySet(self)


    def initDefaults(self):
        """
        initDefaults(CubicBezier self)


        Calls initDefaults from LineSegment.

        """
        return _libsbml.CubicBezier_initDefaults(self)


    def straighten(self):
        """
        straighten(CubicBezier self)


        Turns the CubicBezier into a line by setting both 'basepoint1' and
        'basepoint2' children to the midpoint between the 'start' and the
        'end' points.

        """
        return _libsbml.CubicBezier_straighten(self)


    def getElementName(self):
        """
        getElementName(CubicBezier self) -> string


        Returns the XML element name of this SBML object.

        Returns the string of the name of this element.

        """
        return _libsbml.CubicBezier_getElementName(self)


    def clone(self):
        """
        clone(CubicBezier self) -> CubicBezier


        Creates and returns a deep copy of this CubicBezier.

        Returns a (deep) copy of this CubicBezier.

        """
        return _libsbml.CubicBezier_clone(self)


    def getTypeCode(self):
        """
        getTypeCode(CubicBezier self) -> int


        Returns the libSBML type code of this object instance.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_LAYOUT_CUBICBEZIER.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.CubicBezier_getTypeCode(self)


    def toXML(self):
        """
        toXML(CubicBezier self) -> XMLNode


        Creates an XMLNode object from this.

        """
        return _libsbml.CubicBezier_toXML(self)


    def connectToChild(self):
        """connectToChild(CubicBezier self)"""
        return _libsbml.CubicBezier_connectToChild(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(CubicBezier self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.CubicBezier_enablePackageInternal(self, pkgURI, pkgPrefix, flag)

CubicBezier_swigregister = _libsbml.CubicBezier_swigregister
CubicBezier_swigregister(CubicBezier)

class ListOfLineSegments(ListOf):
    """

    [SBML 'layout' package]

    A list of LineSegment objects.

    The ListOfLineSegments is a container for the LineSegment elements of
    a Curve.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    See also Input.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfLineSegments, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfLineSegments, name)
    __repr__ = _swig_repr

    def clone(self):
        """
        clone(ListOfLineSegments self) -> ListOfLineSegments


        Creates and returns a deep copy of this ListOfLineSegments.

        Returns a (deep) copy of this ListOfLineSegments.

        """
        return _libsbml.ListOfLineSegments_clone(self)


    def __init__(self, *args):
        """
        __init__(ListOfLineSegments self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ListOfLineSegments
        __init__(ListOfLineSegments self, unsigned int level, unsigned int version) -> ListOfLineSegments
        __init__(ListOfLineSegments self, unsigned int level) -> ListOfLineSegments
        __init__(ListOfLineSegments self) -> ListOfLineSegments
        __init__(ListOfLineSegments self, LayoutPkgNamespaces layoutns) -> ListOfLineSegments


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfLineSegments(LayoutPkgNamespaces layoutns)

        Constructor.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'layoutns' is the LayoutPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfLineSegments(long level      =
        LayoutExtension.getDefaultLevel(), long version    =
        LayoutExtension.getDefaultVersion(), long pkgVersion =
        LayoutExtension.getDefaultPackageVersion())

        Constructor.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        this = _libsbml.new_ListOfLineSegments(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfLineSegments self) -> int


        Returns the libSBML type code for the SBML objects contained in this
        ListOf object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for objects contained in this list:
        SBML_LAYOUT_LINESEGMENT (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfLineSegments_getItemTypeCode(self)


    def getElementName(self):
        """
        getElementName(ListOfLineSegments self) -> string


        Returns the XML element name of this SBML object.

        Returns the string of the name of this element.

        """
        return _libsbml.ListOfLineSegments_getElementName(self)


    def get(self, *args):
        """
        get(ListOfLineSegments self, unsigned int n) -> LineSegment
        get(ListOfLineSegments self, unsigned int n) -> LineSegment


        Get a LineSegment from the ListOfLineSegments.

        Parameter 'n' is the index number of the LineSegment to get.

        Returns the nth LineSegment in this ListOfLineSegments. If the index
        'n' is invalid, 'None' is returned.

        See also size().

        """
        return _libsbml.ListOfLineSegments_get(self, *args)


    def remove(self, n):
        """
        remove(ListOfLineSegments self, unsigned int n) -> LineSegment


        Removes the nth item from this ListOfLineSegments items and returns a
        pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the item to remove.

        See also size().

        """
        return _libsbml.ListOfLineSegments_remove(self, n)


    def toXML(self):
        """
        toXML(ListOfLineSegments self) -> XMLNode


        Creates an XMLNode object from this.

        """
        return _libsbml.ListOfLineSegments_toXML(self)

    __swig_destroy__ = _libsbml.delete_ListOfLineSegments
    __del__ = lambda self: None
ListOfLineSegments_swigregister = _libsbml.ListOfLineSegments_swigregister
ListOfLineSegments_swigregister(ListOfLineSegments)

class Curve(SBase):
    """

    [SBML 'layout' package]

    A curve connecting elements in a diagram.

    The Curve class describes how to connect elements in a diagram defined
    with the use of the "layout" package. A curve is fully specified by
    a mandatory listOfCurveSegments element and is used in four places in
    the "layout" package:

    * SpeciesReferenceGlyph: Here it describes a curve from/to the
    center piece of the parent ReactionGlyph to/from the SpeciesGlyph it
    represents.

    * ReactionGlyph: Here it describes a curve for the center piece of
    a reaction.

    * ReferenceGlyph: Here it describes a curve from/to the center
    piece of the parent GeneralGlyph to/from the glyph it represents.

    * GeneralGlyph: Here it describes a curve for the center piece of
    an additional relationship.

    In the text above, the term 'center piece' refers to either the Curve
    element of a ReactionGlyph, or its BoundingBox.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Curve, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Curve, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(Curve self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> Curve
        __init__(Curve self, unsigned int level, unsigned int version) -> Curve
        __init__(Curve self, unsigned int level) -> Curve
        __init__(Curve self) -> Curve
        __init__(Curve self, LayoutPkgNamespaces layoutns) -> Curve
        __init__(Curve self, XMLNode node, unsigned int l2version=4) -> Curve
        __init__(Curve self, XMLNode node) -> Curve
        __init__(Curve self, Curve source) -> Curve


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            Curve(LayoutPkgNamespaces layoutns)

        Creates a new Curve with the given LayoutPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'layoutns' is the LayoutPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        ______________________________________________________________________
        Method variant with the following signature:

            Curve(XMLNode node, long l2version=4)

        Creates a new Curve from the given XMLNode

        ______________________________________________________________________
        Method variant with the following signature:

            Curve(long level      = LayoutExtension.getDefaultLevel(),
        long version    = LayoutExtension.getDefaultVersion(), long pkgVersion
        = LayoutExtension.getDefaultPackageVersion())

        Creates a curve with an empty list of segments.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            Curve(Curve source)

        Copy constructor.

        Parameter 'source' is the instance to copy.

        """
        this = _libsbml.new_Curve(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_Curve
    __del__ = lambda self: None

    def initDefaults(self):
        """
        initDefaults(Curve self)


        Does nothing since no defaults are defined for Curve.

        """
        return _libsbml.Curve_initDefaults(self)


    def getListOfCurveSegments(self):
        """
        getListOfCurveSegments(Curve self) -> ListOfLineSegments


        Returns a reference to the ListOf object that holds all the curve
        segments.

        Returns the ListOfLineSegments of this Curve defined as the child
        listOfCurveSegments.  Will never return None; the listOfCurveSegments
        is always created, even if empty.

        """
        return _libsbml.Curve_getListOfCurveSegments(self)


    def getCurveSegment(self, *args):
        """
        getCurveSegment(Curve self, unsigned int index) -> LineSegment
        getCurveSegment(Curve self, unsigned int index) -> LineSegment


        Returns a pointer to the curve segment with the given index. If the
        index is invalid, 'None' is returned.

        Parameter 'index' is the index value of the curve segment to return.

        Returns the LineSegment representing the child 'curveSegment' with the
        appropriate 'index', or 'None' if no such LineSegment exists.

        """
        return _libsbml.Curve_getCurveSegment(self, *args)


    def addCurveSegment(self, segment):
        """
        addCurveSegment(Curve self, LineSegment segment) -> int


        Adds a copy of the given LineSegment to the end of the
        ListOfLineSegments.

        Parameter 'segment' is the LineSegment to add as a new child
        'curveSegment' of the listOfCurveSegments.

        """
        return _libsbml.Curve_addCurveSegment(self, segment)


    def getNumCurveSegments(self):
        """
        getNumCurveSegments(Curve self) -> unsigned int


        Returns the number of curve segments.

        Returns the number of 'curveSegment' children of this Curve.

        """
        return _libsbml.Curve_getNumCurveSegments(self)


    def createLineSegment(self):
        """
        createLineSegment(Curve self) -> LineSegment


        Creates a new LineSegment and adds it to the end of the list.  A
        reference to the new LineSegment object is returned.

        Returns the LineSegment created as a new child 'curveSegment' of this
        Curve.

        """
        return _libsbml.Curve_createLineSegment(self)


    def createCubicBezier(self):
        """
        createCubicBezier(Curve self) -> CubicBezier


        Creates a new CubicBezier and adds it to the end of the list.  A
        reference to the new CubicBezier object is returned.

        Returns the CubicBezier created as a new child 'curveSegment' of  this
        Curve.

        """
        return _libsbml.Curve_createCubicBezier(self)


    def getElementName(self):
        """
        getElementName(Curve self) -> string


        Returns the XML element name of this SBML object.

        Returns the string of the name of this element.

        """
        return _libsbml.Curve_getElementName(self)


    def clone(self):
        """
        clone(Curve self) -> Curve


        Creates and returns a deep copy of this Curve.

        Returns a (deep) copy of this Curve.

        """
        return _libsbml.Curve_clone(self)


    def getTypeCode(self):
        """
        getTypeCode(Curve self) -> int


        Returns the libSBML type code of this object instance.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_LAYOUT_CURVE.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.Curve_getTypeCode(self)


    def toXML(self):
        """
        toXML(Curve self) -> XMLNode


        Creates an XMLNode object from this.

        """
        return _libsbml.Curve_toXML(self)


    def connectToChild(self):
        """connectToChild(Curve self)"""
        return _libsbml.Curve_connectToChild(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(Curve self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.Curve_enablePackageInternal(self, pkgURI, pkgPrefix, flag)

Curve_swigregister = _libsbml.Curve_swigregister
Curve_swigregister(Curve)

class SpeciesReferenceGlyph(GraphicalObject):
    """

    [SBML 'layout' package]

    A glyph for an SBML species reference.

    The SpeciesReferenceGlyph element describes the graphical connection
    between a SpeciesGlyph and a ReactionGlyph (which would be an arrow or
    some curve in most cases). A SpeciesReferenceGlyph inherits from
    GraphicalObject, and adds a mandatory attribute 'speciesGlyph' and two
    optional attributes 'speciesReference' and 'role'. Optionally, the
    SpeciesReferenceGlyph also has a child element 'curve'.

    If the curve is specified, it overrides the inherited bounding box.

    """

    __swig_setmethods__ = {}
    for _s in [GraphicalObject]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SpeciesReferenceGlyph, name, value)
    __swig_getmethods__ = {}
    for _s in [GraphicalObject]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SpeciesReferenceGlyph, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(SpeciesReferenceGlyph self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> SpeciesReferenceGlyph
        __init__(SpeciesReferenceGlyph self, unsigned int level, unsigned int version) -> SpeciesReferenceGlyph
        __init__(SpeciesReferenceGlyph self, unsigned int level) -> SpeciesReferenceGlyph
        __init__(SpeciesReferenceGlyph self) -> SpeciesReferenceGlyph
        __init__(SpeciesReferenceGlyph self, LayoutPkgNamespaces layoutns) -> SpeciesReferenceGlyph
        __init__(SpeciesReferenceGlyph self, LayoutPkgNamespaces layoutns, string sid, string speciesGlyphId, string speciesReferenceId, SpeciesReferenceRole_t role) -> SpeciesReferenceGlyph
        __init__(SpeciesReferenceGlyph self, XMLNode node, unsigned int l2version=4) -> SpeciesReferenceGlyph
        __init__(SpeciesReferenceGlyph self, XMLNode node) -> SpeciesReferenceGlyph
        __init__(SpeciesReferenceGlyph self, SpeciesReferenceGlyph source) -> SpeciesReferenceGlyph


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            SpeciesReferenceGlyph(SpeciesReferenceGlyph source)

        Copy constructor.

        Parameter 'source' is the instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            SpeciesReferenceGlyph(LayoutPkgNamespaces layoutns)

        Constructor.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'layoutns' is the LayoutPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        ______________________________________________________________________
        Method variant with the following signature:

            SpeciesReferenceGlyph(XMLNode node, long l2version=4)

        Creates a new SpeciesReferenceGlyph from the given XMLNode

        ______________________________________________________________________
        Method variant with the following signature:

            SpeciesReferenceGlyph(long level      =
        LayoutExtension.getDefaultLevel(), long version    =
        LayoutExtension.getDefaultVersion(), long pkgVersion =
        LayoutExtension.getDefaultPackageVersion())

        Creates a new SpeciesReferenceGlyph with the given SBML level, version
        and package version.  The id if the associated species reference and
        the id of the associated species glyph are set to the empty string.
        The role is set to SPECIES_ROLE_INVALID.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            SpeciesReferenceGlyph(LayoutPkgNamespaces layoutns, string
        sid, string speciesGlyphId, string speciesReferenceId,
        SpeciesReferenceRole_t role )

        Creates a new SpeciesReferenceGlyph.  The id is given as the first
        argument, the id of the associated species glyph is given as the
        second argument.  The third argument is the id of the associated
        species reference and the fourth argument is the role.

        """
        this = _libsbml.new_SpeciesReferenceGlyph(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_SpeciesReferenceGlyph
    __del__ = lambda self: None

    def getSpeciesGlyphId(self):
        """
        getSpeciesGlyphId(SpeciesReferenceGlyph self) -> string


        Returns the id of the associated SpeciesGlyph.

        """
        return _libsbml.SpeciesReferenceGlyph_getSpeciesGlyphId(self)


    def setSpeciesGlyphId(self, speciesGlyphId):
        """
        setSpeciesGlyphId(SpeciesReferenceGlyph self, string speciesGlyphId)


        Sets the id of the associated species glyph.

        """
        return _libsbml.SpeciesReferenceGlyph_setSpeciesGlyphId(self, speciesGlyphId)


    def getSpeciesReferenceId(self):
        """
        getSpeciesReferenceId(SpeciesReferenceGlyph self) -> string


        Returns the id of the associated species reference.

        """
        return _libsbml.SpeciesReferenceGlyph_getSpeciesReferenceId(self)


    def setSpeciesReferenceId(self, id):
        """
        setSpeciesReferenceId(SpeciesReferenceGlyph self, string id)


        Sets the id of the associated species reference.

        """
        return _libsbml.SpeciesReferenceGlyph_setSpeciesReferenceId(self, id)


    def getRoleString(self):
        """
        getRoleString(SpeciesReferenceGlyph self) -> string


        Returns a string representation of the role.

        """
        return _libsbml.SpeciesReferenceGlyph_getRoleString(self)


    def getRole(self):
        """
        getRole(SpeciesReferenceGlyph self) -> SpeciesReferenceRole_t


        Returns the role.

        """
        return _libsbml.SpeciesReferenceGlyph_getRole(self)


    def setRole(self, *args):
        """
        setRole(SpeciesReferenceGlyph self, string role)
        setRole(SpeciesReferenceGlyph self, SpeciesReferenceRole_t role)


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            setRole(SpeciesReferenceRole_t role)

        Sets the role.

        ______________________________________________________________________
        Method variant with the following signature:

            setRole(string role)

        Sets the role based on a string. The String can be one of: SUBSTRATE
        PRODUCT SIDESUBSTRATE SIDEPRODUCT MODIFIER ACTIVATOR INHIBITOR

        """
        return _libsbml.SpeciesReferenceGlyph_setRole(self, *args)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(SpeciesReferenceGlyph self, string oldid, string newid)


        Replaces all uses of a given 'SIdRef' type attribute value with
        another value.

        In SBML, object identifiers are of a data type called SId. In SBML
        Level 3, an explicit data type called SIdRef was introduced for
        attribute values that refer to SId values; in previous Levels of SBML,
        this data type did not exist and attributes were simply described to
        as 'referring to an identifier', but the effective data type was the
        same as SIdRef in Level 3.  These and other methods of libSBML refer
        to the type SIdRef for all Levels of SBML, even if the corresponding
        SBML specification did not explicitly name the data type.

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas in MathML content, comparing the referenced
        identifiers to the value of 'oldid'.  If any matches are found, the
        matching values are replaced with 'newid'.  The method does not
        descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.SpeciesReferenceGlyph_renameSIdRefs(self, oldid, newid)


    def getCurve(self, *args):
        """
        getCurve(SpeciesReferenceGlyph self) -> Curve
        getCurve(SpeciesReferenceGlyph self) -> Curve


        Returns the curve object for the species reference glyph

        """
        return _libsbml.SpeciesReferenceGlyph_getCurve(self, *args)


    def setCurve(self, curve):
        """
        setCurve(SpeciesReferenceGlyph self, Curve curve)


        Sets the curve object for the species reference glyph.

        """
        return _libsbml.SpeciesReferenceGlyph_setCurve(self, curve)


    def isSetCurve(self):
        """
        isSetCurve(SpeciesReferenceGlyph self) -> bool


        Returns 'True' if the curve consists of one or more segments.

        """
        return _libsbml.SpeciesReferenceGlyph_isSetCurve(self)


    def getCurveExplicitlySet(self):
        """
        getCurveExplicitlySet(SpeciesReferenceGlyph self) -> bool




        """
        return _libsbml.SpeciesReferenceGlyph_getCurveExplicitlySet(self)


    def isSetSpeciesGlyphId(self):
        """
        isSetSpeciesGlyphId(SpeciesReferenceGlyph self) -> bool


        Returns 'True' if the id of the associated species glyph is not the
        empty string.

        """
        return _libsbml.SpeciesReferenceGlyph_isSetSpeciesGlyphId(self)


    def isSetSpeciesReferenceId(self):
        """
        isSetSpeciesReferenceId(SpeciesReferenceGlyph self) -> bool


        Returns 'True' if the id of the associated species reference is not
        the empty string.

        """
        return _libsbml.SpeciesReferenceGlyph_isSetSpeciesReferenceId(self)


    def isSetRole(self):
        """
        isSetRole(SpeciesReferenceGlyph self) -> bool


        Returns 'True' of role is different from SPECIES_ROLE_INVALID.

        """
        return _libsbml.SpeciesReferenceGlyph_isSetRole(self)


    def initDefaults(self):
        """
        initDefaults(SpeciesReferenceGlyph self)


        Calls initDefaults on GraphicalObject and sets role to
        SPECIES_ROLE_INVALID.

        """
        return _libsbml.SpeciesReferenceGlyph_initDefaults(self)


    def createLineSegment(self):
        """
        createLineSegment(SpeciesReferenceGlyph self) -> LineSegment


        Creates a new LineSegment object, adds it to the end of the list of
        curve segment objects of the curve and returns a reference to the
        newly created object.

        """
        return _libsbml.SpeciesReferenceGlyph_createLineSegment(self)


    def createCubicBezier(self):
        """
        createCubicBezier(SpeciesReferenceGlyph self) -> CubicBezier


        Creates a new CubicBezier object, adds it to the end of the list of
        curve segment objects of the curve and returns a reference to the
        newly created object.

        """
        return _libsbml.SpeciesReferenceGlyph_createCubicBezier(self)


    def getElementName(self):
        """
        getElementName(SpeciesReferenceGlyph self) -> string


        Returns the XML element name of this SBML object.

        Returns the string of the name of this element.

        """
        return _libsbml.SpeciesReferenceGlyph_getElementName(self)


    def clone(self):
        """
        clone(SpeciesReferenceGlyph self) -> SpeciesReferenceGlyph


        Creates and returns a deep copy of this SpeciesReferenceGlyph.

        Returns a (deep) copy of this SpeciesReferenceGlyph.

        """
        return _libsbml.SpeciesReferenceGlyph_clone(self)


    def getTypeCode(self):
        """
        getTypeCode(SpeciesReferenceGlyph self) -> int


        Returns the libSBML type code of this object instance.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object:
        SBML_LAYOUT_SPECIESREFERENCEGLYPH.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.SpeciesReferenceGlyph_getTypeCode(self)


    def toXML(self):
        """
        toXML(SpeciesReferenceGlyph self) -> XMLNode


        Creates an XMLNode object from this.

        """
        return _libsbml.SpeciesReferenceGlyph_toXML(self)


    def connectToChild(self):
        """connectToChild(SpeciesReferenceGlyph self)"""
        return _libsbml.SpeciesReferenceGlyph_connectToChild(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(SpeciesReferenceGlyph self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.SpeciesReferenceGlyph_enablePackageInternal(self, pkgURI, pkgPrefix, flag)

SpeciesReferenceGlyph_swigregister = _libsbml.SpeciesReferenceGlyph_swigregister
SpeciesReferenceGlyph_swigregister(SpeciesReferenceGlyph)

class ReferenceGlyph(GraphicalObject):
    """

    [SBML 'layout' package]

    Connection between an object and a glyph.

    The ReferenceGlyph element describes the graphical connection between
    an arbitrary GraphicalObject (or derived element) and a GeneralGlyph
    (which would be an arrow or some curve in most cases). A
    ReferenceGlyph inherits from GraphicalObject. Additionally it has a
    mandatory attribute 'glyph' and two optional attributes 'reference'
    and 'role'. Optionally, the ReferenceGlyph also has an element
    'curve'.  The ReferenceGlyph should either contain a bounding box or a
    curve specification.  If both are given, the bounding box should be
    ignored.

    """

    __swig_setmethods__ = {}
    for _s in [GraphicalObject]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ReferenceGlyph, name, value)
    __swig_getmethods__ = {}
    for _s in [GraphicalObject]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ReferenceGlyph, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ReferenceGlyph self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ReferenceGlyph
        __init__(ReferenceGlyph self, unsigned int level, unsigned int version) -> ReferenceGlyph
        __init__(ReferenceGlyph self, unsigned int level) -> ReferenceGlyph
        __init__(ReferenceGlyph self) -> ReferenceGlyph
        __init__(ReferenceGlyph self, LayoutPkgNamespaces layoutns) -> ReferenceGlyph
        __init__(ReferenceGlyph self, LayoutPkgNamespaces layoutns, string sid, string glyphId, string referenceId, string role) -> ReferenceGlyph
        __init__(ReferenceGlyph self, XMLNode node, unsigned int l2version=4) -> ReferenceGlyph
        __init__(ReferenceGlyph self, XMLNode node) -> ReferenceGlyph
        __init__(ReferenceGlyph self, ReferenceGlyph source) -> ReferenceGlyph


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ReferenceGlyph(LayoutPkgNamespaces layoutns, string sid,
        string glyphId, string referenceId, string role )

        Creates a new ReferenceGlyph.  The id is given as the first argument,
        the id of the associated glyph is given as the second argument.  The
        third argument is the id of the associated reference and the fourth
        argument is the role.

        ______________________________________________________________________
        Method variant with the following signature:

            ReferenceGlyph(LayoutPkgNamespaces layoutns)

        Constructor.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'layoutns' is the LayoutPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        ______________________________________________________________________
        Method variant with the following signature:

            ReferenceGlyph(XMLNode node, long l2version=4)

        Creates a new ReferenceGlyph from the given XMLNode

        ______________________________________________________________________
        Method variant with the following signature:

            ReferenceGlyph(ReferenceGlyph source)

        Copy constructor.

        Parameter 'source' is the instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            ReferenceGlyph(long level      =
        LayoutExtension.getDefaultLevel(), long version    =
        LayoutExtension.getDefaultVersion(), long pkgVersion =
        LayoutExtension.getDefaultPackageVersion())

        Creates a new ReferenceGlyph with the given SBML level, version and
        package version.  The id if the associated  reference and the id of
        the associated  glyph are set to the empty string.  The role is set to
        empty.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        this = _libsbml.new_ReferenceGlyph(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_ReferenceGlyph
    __del__ = lambda self: None

    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(ReferenceGlyph self, string oldid, string newid)


        Replaces all uses of a given 'SIdRef' type attribute value with
        another value.

        In SBML, object identifiers are of a data type called SId. In SBML
        Level 3, an explicit data type called SIdRef was introduced for
        attribute values that refer to SId values; in previous Levels of SBML,
        this data type did not exist and attributes were simply described to
        as 'referring to an identifier', but the effective data type was the
        same as SIdRef in Level 3.  These and other methods of libSBML refer
        to the type SIdRef for all Levels of SBML, even if the corresponding
        SBML specification did not explicitly name the data type.

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas in MathML content, comparing the referenced
        identifiers to the value of 'oldid'.  If any matches are found, the
        matching values are replaced with 'newid'.  The method does not
        descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.ReferenceGlyph_renameSIdRefs(self, oldid, newid)


    def getGlyphId(self):
        """
        getGlyphId(ReferenceGlyph self) -> string


        Returns the id of the associated glyph.

        """
        return _libsbml.ReferenceGlyph_getGlyphId(self)


    def setGlyphId(self, glyphId):
        """
        setGlyphId(ReferenceGlyph self, string glyphId)


        Sets the id of the associated glyph.

        """
        return _libsbml.ReferenceGlyph_setGlyphId(self, glyphId)


    def getReferenceId(self):
        """
        getReferenceId(ReferenceGlyph self) -> string


        Returns the id of the associated sbml reference.

        """
        return _libsbml.ReferenceGlyph_getReferenceId(self)


    def setReferenceId(self, id):
        """
        setReferenceId(ReferenceGlyph self, string id)


        Sets the id of the associated sbml reference.

        """
        return _libsbml.ReferenceGlyph_setReferenceId(self, id)


    def getRole(self):
        """
        getRole(ReferenceGlyph self) -> string


        Returns a string representation of the role.

        """
        return _libsbml.ReferenceGlyph_getRole(self)


    def setRole(self, role):
        """
        setRole(ReferenceGlyph self, string role)


        Sets the role.

        """
        return _libsbml.ReferenceGlyph_setRole(self, role)


    def getCurve(self, *args):
        """
        getCurve(ReferenceGlyph self) -> Curve
        getCurve(ReferenceGlyph self) -> Curve


        Returns the curve object for the reference glyph

        """
        return _libsbml.ReferenceGlyph_getCurve(self, *args)


    def setCurve(self, curve):
        """
        setCurve(ReferenceGlyph self, Curve curve)


        Sets the curve object for the reference glyph.

        """
        return _libsbml.ReferenceGlyph_setCurve(self, curve)


    def isSetCurve(self):
        """
        isSetCurve(ReferenceGlyph self) -> bool


        Returns 'True' if the curve consists of one or more segments.

        """
        return _libsbml.ReferenceGlyph_isSetCurve(self)


    def getCurveExplicitlySet(self):
        """
        getCurveExplicitlySet(ReferenceGlyph self) -> bool




        """
        return _libsbml.ReferenceGlyph_getCurveExplicitlySet(self)


    def isSetGlyphId(self):
        """
        isSetGlyphId(ReferenceGlyph self) -> bool


        Returns 'True' if the id of the associated glyph is not the empty
        string.

        """
        return _libsbml.ReferenceGlyph_isSetGlyphId(self)


    def isSetReferenceId(self):
        """
        isSetReferenceId(ReferenceGlyph self) -> bool


        Returns 'True' if the id of the associated reference is not the empty
        string.

        """
        return _libsbml.ReferenceGlyph_isSetReferenceId(self)


    def isSetRole(self):
        """
        isSetRole(ReferenceGlyph self) -> bool


        Returns 'True' of role is different from the empty string.

        """
        return _libsbml.ReferenceGlyph_isSetRole(self)


    def initDefaults(self):
        """
        initDefaults(ReferenceGlyph self)


        Calls initDefaults on GraphicalObject

        """
        return _libsbml.ReferenceGlyph_initDefaults(self)


    def createLineSegment(self):
        """
        createLineSegment(ReferenceGlyph self) -> LineSegment


        Creates a new LineSegment object, adds it to the end of the list of
        curve segment objects of the curve and returns a reference to the
        newly created object.

        """
        return _libsbml.ReferenceGlyph_createLineSegment(self)


    def createCubicBezier(self):
        """
        createCubicBezier(ReferenceGlyph self) -> CubicBezier


        Creates a new CubicBezier object, adds it to the end of the list of
        curve segment objects of the curve and returns a reference to the
        newly created object.

        """
        return _libsbml.ReferenceGlyph_createCubicBezier(self)


    def getElementName(self):
        """
        getElementName(ReferenceGlyph self) -> string


        Returns the XML element name of this SBML object.

        Returns the string of the name of this element.

        """
        return _libsbml.ReferenceGlyph_getElementName(self)


    def clone(self):
        """
        clone(ReferenceGlyph self) -> ReferenceGlyph


        Creates and returns a deep copy of this ReferenceGlyph.

        Returns a (deep) copy of this ReferenceGlyph.

        """
        return _libsbml.ReferenceGlyph_clone(self)


    def getTypeCode(self):
        """
        getTypeCode(ReferenceGlyph self) -> int


        Returns the libSBML type code of this object instance.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object:
        SBML_LAYOUT_REFERENCEGLYPH.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ReferenceGlyph_getTypeCode(self)


    def toXML(self):
        """
        toXML(ReferenceGlyph self) -> XMLNode


        Creates an XMLNode object from this.

        """
        return _libsbml.ReferenceGlyph_toXML(self)


    def connectToChild(self):
        """connectToChild(ReferenceGlyph self)"""
        return _libsbml.ReferenceGlyph_connectToChild(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(ReferenceGlyph self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.ReferenceGlyph_enablePackageInternal(self, pkgURI, pkgPrefix, flag)

ReferenceGlyph_swigregister = _libsbml.ReferenceGlyph_swigregister
ReferenceGlyph_swigregister(ReferenceGlyph)

class ListOfReferenceGlyphs(ListOf):
    """

    [SBML 'layout' package]

    A list of ReferenceGlyph objects.

    The ListOfReferenceGlyphs is a container for the ReferenceGlyph
    elements of a GeneralGlyph.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    See also ReferenceGlyph.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfReferenceGlyphs, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfReferenceGlyphs, name)
    __repr__ = _swig_repr

    def clone(self):
        """
        clone(ListOfReferenceGlyphs self) -> ListOfReferenceGlyphs


        Creates and returns a deep copy of this ListOfReferenceGlyphs.

        Returns a (deep) copy of this ListOfReferenceGlyphs.

        """
        return _libsbml.ListOfReferenceGlyphs_clone(self)


    def __init__(self, *args):
        """
        __init__(ListOfReferenceGlyphs self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ListOfReferenceGlyphs
        __init__(ListOfReferenceGlyphs self, unsigned int level, unsigned int version) -> ListOfReferenceGlyphs
        __init__(ListOfReferenceGlyphs self, unsigned int level) -> ListOfReferenceGlyphs
        __init__(ListOfReferenceGlyphs self) -> ListOfReferenceGlyphs
        __init__(ListOfReferenceGlyphs self, LayoutPkgNamespaces layoutns) -> ListOfReferenceGlyphs


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfReferenceGlyphs(LayoutPkgNamespaces layoutns)

        Constructor.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'layoutns' is the LayoutPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfReferenceGlyphs(long level      =
        LayoutExtension.getDefaultLevel(), long version    =
        LayoutExtension.getDefaultVersion(), long pkgVersion =
        LayoutExtension.getDefaultPackageVersion())

        Constructor.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        this = _libsbml.new_ListOfReferenceGlyphs(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfReferenceGlyphs self) -> int


        Returns the libSBML type code for the SBML objects contained in this
        ListOf object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for objects contained in this list:
        SBML_LAYOUT_REFERENCEGLYPH (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfReferenceGlyphs_getItemTypeCode(self)


    def getElementName(self):
        """
        getElementName(ListOfReferenceGlyphs self) -> string


        Returns the XML element name of this SBML object.

        Returns the string of the name of this element.

        """
        return _libsbml.ListOfReferenceGlyphs_getElementName(self)


    def get(self, *args):
        """
        get(ListOfReferenceGlyphs self, unsigned int n) -> ReferenceGlyph
        get(ListOfReferenceGlyphs self, unsigned int n) -> ReferenceGlyph
        get(ListOfReferenceGlyphs self, string sid) -> ReferenceGlyph
        get(ListOfReferenceGlyphs self, string sid) -> ReferenceGlyph


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a ReferenceGlyph from the ListOfReferenceGlyphs.

        Parameter 'n' is the index number of the ReferenceGlyph to get.

        Returns the nth ReferenceGlyph in this ListOfReferenceGlyphs. If the
        index 'n' is invalid, 'None' is returned.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a ReferenceGlyph from the ListOfReferenceGlyphs based on its
        identifier.

        Parameter 'sid' is a string representing the identifier  of the
        ReferenceGlyph to get.

        Returns ReferenceGlyph in this ListOfReferenceGlyphs with the given
        'sid' or 'None' if no such ReferenceGlyph exists.

        See also get(), size().

        """
        return _libsbml.ListOfReferenceGlyphs_get(self, *args)


    def remove(self, *args):
        """
        remove(ListOfReferenceGlyphs self, unsigned int n) -> ReferenceGlyph
        remove(ListOfReferenceGlyphs self, string sid) -> ReferenceGlyph


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth item from this ListOfReferenceGlyphs items and returns
        a pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the item to remove.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes item in this ListOfReferenceGlyphs 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 'sid', then
        'None' is returned.

        Parameter 'sid' is the identifier of the item to remove.

        Returns the item removed.  As mentioned above, the caller owns the
        returned item.

        """
        return _libsbml.ListOfReferenceGlyphs_remove(self, *args)


    def toXML(self):
        """
        toXML(ListOfReferenceGlyphs self) -> XMLNode


        Creates an XMLNode object from this.

        """
        return _libsbml.ListOfReferenceGlyphs_toXML(self)

    __swig_destroy__ = _libsbml.delete_ListOfReferenceGlyphs
    __del__ = lambda self: None
ListOfReferenceGlyphs_swigregister = _libsbml.ListOfReferenceGlyphs_swigregister
ListOfReferenceGlyphs_swigregister(ListOfReferenceGlyphs)

class GeneralGlyph(GraphicalObject):
    """

    [SBML 'layout' package]

    A glyph for miscellaneous items.

    The GeneralGlyph is used to facilitate the representation of elements
    other than Compartment, Species and Reaction and thus can be used for
    the display of relationships of Rule or elements defined by other SBML
    packages. It closely follows the structure of the ReactionGlyph.
    GeneralGlyph is defined to have an optional attribute reference as
    well as the elements curve, listOfReferenceGlyphs and listOfSubGlyphs.

    """

    __swig_setmethods__ = {}
    for _s in [GraphicalObject]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GeneralGlyph, name, value)
    __swig_getmethods__ = {}
    for _s in [GraphicalObject]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, GeneralGlyph, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(GeneralGlyph self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> GeneralGlyph
        __init__(GeneralGlyph self, unsigned int level, unsigned int version) -> GeneralGlyph
        __init__(GeneralGlyph self, unsigned int level) -> GeneralGlyph
        __init__(GeneralGlyph self) -> GeneralGlyph
        __init__(GeneralGlyph self, LayoutPkgNamespaces layoutns) -> GeneralGlyph
        __init__(GeneralGlyph self, LayoutPkgNamespaces layoutns, string id) -> GeneralGlyph
        __init__(GeneralGlyph self, LayoutPkgNamespaces layoutns, string id, string referenceId) -> GeneralGlyph
        __init__(GeneralGlyph self, XMLNode node, unsigned int l2version=4) -> GeneralGlyph
        __init__(GeneralGlyph self, XMLNode node) -> GeneralGlyph
        __init__(GeneralGlyph self, GeneralGlyph source) -> GeneralGlyph


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            GeneralGlyph(GeneralGlyph source)

        Copy constructor.

        Parameter 'source' is the instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            GeneralGlyph(LayoutPkgNamespaces layoutns, string id, string
        referenceId)

        Creates a glyph with the given LayoutPkgNamespaces, id and set the id
        of the associated element to the second argument.

        (FOR BACKWARD COMPATIBILITY)

        ______________________________________________________________________
        Method variant with the following signature:

            GeneralGlyph(long level      =
        LayoutExtension.getDefaultLevel(), long version    =
        LayoutExtension.getDefaultVersion(), long pkgVersion =
        LayoutExtension.getDefaultPackageVersion())

        Creates a new GeneralGlyph.  The list of reference glyph and subglyphs
        is empty and the id of the associated element is set to the empty
        string.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            GeneralGlyph(XMLNode node, long l2version = 4)

        Creates a new GeneralGlyph from the given XMLNode

        (FOR BACKWARD COMPATIBILITY)

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            GeneralGlyph(LayoutPkgNamespaces layoutns)

        Creates a new GeneralGlyph with the given LayoutPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'layoutns' is the LayoutPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        ______________________________________________________________________
        Method variant with the following signature:

            GeneralGlyph(LayoutPkgNamespaces layoutns, string id)

        Creates a glyph with the given LayoutPkgNamespaces and id.

        (FOR BACKWARD COMPATIBILITY)

        """
        this = _libsbml.new_GeneralGlyph(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_GeneralGlyph
    __del__ = lambda self: None

    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(GeneralGlyph self, string oldid, string newid)


        Replaces all uses of a given 'SIdRef' type attribute value with
        another value.

        In SBML, object identifiers are of a data type called SId. In SBML
        Level 3, an explicit data type called SIdRef was introduced for
        attribute values that refer to SId values; in previous Levels of SBML,
        this data type did not exist and attributes were simply described to
        as 'referring to an identifier', but the effective data type was the
        same as SIdRef in Level 3.  These and other methods of libSBML refer
        to the type SIdRef for all Levels of SBML, even if the corresponding
        SBML specification did not explicitly name the data type.

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas in MathML content, comparing the referenced
        identifiers to the value of 'oldid'.  If any matches are found, the
        matching values are replaced with 'newid'.  The method does not
        descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.GeneralGlyph_renameSIdRefs(self, oldid, newid)


    def getReferenceId(self):
        """
        getReferenceId(GeneralGlyph self) -> string


        Returns the id of the associated element.

        """
        return _libsbml.GeneralGlyph_getReferenceId(self)


    def setReferenceId(self, id):
        """
        setReferenceId(GeneralGlyph self, string id) -> int


        Sets the id of the associated element.

        """
        return _libsbml.GeneralGlyph_setReferenceId(self, id)


    def isSetReferenceId(self):
        """
        isSetReferenceId(GeneralGlyph self) -> bool


        Returns 'True' if the id of the associated element is not the empty
        string.

        """
        return _libsbml.GeneralGlyph_isSetReferenceId(self)


    def getListOfReferenceGlyphs(self, *args):
        """
        getListOfReferenceGlyphs(GeneralGlyph self) -> ListOfReferenceGlyphs
        getListOfReferenceGlyphs(GeneralGlyph self) -> ListOfReferenceGlyphs


        Returns the ListOf object that hold the reference glyphs.

        """
        return _libsbml.GeneralGlyph_getListOfReferenceGlyphs(self, *args)


    def getListOfSubGlyphs(self, *args):
        """
        getListOfSubGlyphs(GeneralGlyph self) -> ListOfGraphicalObjects
        getListOfSubGlyphs(GeneralGlyph self) -> ListOfGraphicalObjects


        Returns the ListOf object that hold the sub glyphs.

        """
        return _libsbml.GeneralGlyph_getListOfSubGlyphs(self, *args)


    def getReferenceGlyph(self, *args):
        """
        getReferenceGlyph(GeneralGlyph self, unsigned int index) -> ReferenceGlyph
        getReferenceGlyph(GeneralGlyph self, unsigned int index) -> ReferenceGlyph


        Returns the reference glyph with the given 'index'. If the index is
        invalid, 'None' is returned.

        """
        return _libsbml.GeneralGlyph_getReferenceGlyph(self, *args)


    def getSubGlyph(self, *args):
        """
        getSubGlyph(GeneralGlyph self, unsigned int index) -> GraphicalObject
        getSubGlyph(GeneralGlyph self, unsigned int index) -> GraphicalObject


        Returns the sub glyph with the given 'index'. If the index is invalid,
        'None' is returned.

        """
        return _libsbml.GeneralGlyph_getSubGlyph(self, *args)


    def addReferenceGlyph(self, glyph):
        """
        addReferenceGlyph(GeneralGlyph self, ReferenceGlyph glyph) -> int


        Adds a new reference glyph to the list.

        """
        return _libsbml.GeneralGlyph_addReferenceGlyph(self, glyph)


    def addSubGlyph(self, glyph):
        """
        addSubGlyph(GeneralGlyph self, GraphicalObject glyph) -> int


        Adds a new subglyph to the list.

        """
        return _libsbml.GeneralGlyph_addSubGlyph(self, glyph)


    def getNumReferenceGlyphs(self):
        """
        getNumReferenceGlyphs(GeneralGlyph self) -> unsigned int


        Returns the number of reference glyph objects.

        """
        return _libsbml.GeneralGlyph_getNumReferenceGlyphs(self)


    def getNumSubGlyphs(self):
        """
        getNumSubGlyphs(GeneralGlyph self) -> unsigned int


        Returns the number of subglyph objects.

        """
        return _libsbml.GeneralGlyph_getNumSubGlyphs(self)


    def initDefaults(self):
        """
        initDefaults(GeneralGlyph self)


        Calls initDefaults from GraphicalObject.

        """
        return _libsbml.GeneralGlyph_initDefaults(self)


    def getCurve(self, *args):
        """
        getCurve(GeneralGlyph self) -> Curve
        getCurve(GeneralGlyph self) -> Curve


        Returns the curve object for the reaction glyph

        """
        return _libsbml.GeneralGlyph_getCurve(self, *args)


    def setCurve(self, curve):
        """
        setCurve(GeneralGlyph self, Curve curve)


        Sets the curve object for the reaction glyph.

        """
        return _libsbml.GeneralGlyph_setCurve(self, curve)


    def isSetCurve(self):
        """
        isSetCurve(GeneralGlyph self) -> bool


        Returns 'True' if the curve consists of one or more segments.

        """
        return _libsbml.GeneralGlyph_isSetCurve(self)


    def getCurveExplicitlySet(self):
        """
        getCurveExplicitlySet(GeneralGlyph self) -> bool




        """
        return _libsbml.GeneralGlyph_getCurveExplicitlySet(self)


    def createReferenceGlyph(self):
        """
        createReferenceGlyph(GeneralGlyph self) -> ReferenceGlyph


        Creates a new ReferenceGlyph object, adds it to the end of the list of
        reference objects and returns a reference to the newly created object.

        """
        return _libsbml.GeneralGlyph_createReferenceGlyph(self)


    def createLineSegment(self):
        """
        createLineSegment(GeneralGlyph self) -> LineSegment


        Creates a new LineSegment object, adds it to the end of the list of
        curve segment objects of the curve and returns a reference to the
        newly created object.

        """
        return _libsbml.GeneralGlyph_createLineSegment(self)


    def createCubicBezier(self):
        """
        createCubicBezier(GeneralGlyph self) -> CubicBezier


        Creates a new CubicBezier object, adds it to the end of the list of
        curve segment objects of the curve and returns a reference to the
        newly created object.

        """
        return _libsbml.GeneralGlyph_createCubicBezier(self)


    def removeReferenceGlyph(self, *args):
        """
        removeReferenceGlyph(GeneralGlyph self, unsigned int index) -> ReferenceGlyph
        removeReferenceGlyph(GeneralGlyph self, string id) -> ReferenceGlyph


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeReferenceGlyph(long index)

        Remove the reference glyph with the given 'index'. A pointer to the
        object is returned. If no object has been removed, None is returned.

        ______________________________________________________________________
        Method variant with the following signature:

            removeReferenceGlyph(string id)

        Remove the reference glyph with the given 'id'. A pointer to the
        object is returned. If no object has been removed, None is returned.

        """
        return _libsbml.GeneralGlyph_removeReferenceGlyph(self, *args)


    def removeSubGlyph(self, *args):
        """
        removeSubGlyph(GeneralGlyph self, unsigned int index) -> GraphicalObject
        removeSubGlyph(GeneralGlyph self, string id) -> GraphicalObject


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeSubGlyph(long index)

        Remove the subglyph with the given 'index'. A pointer to the object is
        returned. If no object has been removed, None is returned.

        ______________________________________________________________________
        Method variant with the following signature:

            removeSubGlyph(string id)

        Remove the subglyph with the given 'id'. A pointer to the object is
        returned. If no object has been removed, None is returned.

        """
        return _libsbml.GeneralGlyph_removeSubGlyph(self, *args)


    def getIndexForReferenceGlyph(self, id):
        """
        getIndexForReferenceGlyph(GeneralGlyph self, string id) -> unsigned int


        Returns the index of the reference glyph with the given 'id'. If the
        glyph does not contain a reference glyph with this id, cpp the value
        of the maximum long integer is returned as an indicator.

        """
        return _libsbml.GeneralGlyph_getIndexForReferenceGlyph(self, id)


    def getIndexForSubGlyph(self, id):
        """
        getIndexForSubGlyph(GeneralGlyph self, string id) -> unsigned int


        Returns the index of the subglyph with the given 'id'. If the glyph
        does not contain a subglyph with this id, cpp the value of the maximum
        long integer is returned as an indicator.

        """
        return _libsbml.GeneralGlyph_getIndexForSubGlyph(self, id)


    def getElementName(self):
        """
        getElementName(GeneralGlyph self) -> string


        Returns the XML element name of this SBML object.

        Returns the string of the name of this element.

        """
        return _libsbml.GeneralGlyph_getElementName(self)


    def clone(self):
        """
        clone(GeneralGlyph self) -> GeneralGlyph


        Creates and returns a deep copy of this GeneralGlyph.

        Returns a (deep) copy of this GeneralGlyph.

        """
        return _libsbml.GeneralGlyph_clone(self)


    def getTypeCode(self):
        """
        getTypeCode(GeneralGlyph self) -> int


        Returns the libSBML type code of this object instance.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_LAYOUT_GENERALGLYPH.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.GeneralGlyph_getTypeCode(self)


    def toXML(self):
        """
        toXML(GeneralGlyph self) -> XMLNode


        Creates an XMLNode object from this.

        """
        return _libsbml.GeneralGlyph_toXML(self)


    def connectToChild(self):
        """connectToChild(GeneralGlyph self)"""
        return _libsbml.GeneralGlyph_connectToChild(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(GeneralGlyph self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.GeneralGlyph_enablePackageInternal(self, pkgURI, pkgPrefix, flag)

GeneralGlyph_swigregister = _libsbml.GeneralGlyph_swigregister
GeneralGlyph_swigregister(GeneralGlyph)

class ListOfSpeciesReferenceGlyphs(ListOf):
    """

    [SBML 'layout' package]

    A list of SpeciesReferenceGlyph objects.

    The ListOfSpeciesReferenceGlyphs is a container for the
    SpeciesReferenceGlyphs elements of a ReactionGlyph.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    See also SpeciesReferenceGlyph.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfSpeciesReferenceGlyphs, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfSpeciesReferenceGlyphs, name)
    __repr__ = _swig_repr

    def clone(self):
        """
        clone(ListOfSpeciesReferenceGlyphs self) -> ListOfSpeciesReferenceGlyphs


        Creates and returns a deep copy of this ListOfSpeciesReferenceGlyphs.

        Returns a (deep) copy of this ListOfSpeciesReferenceGlyphs.

        """
        return _libsbml.ListOfSpeciesReferenceGlyphs_clone(self)


    def __init__(self, *args):
        """
        __init__(ListOfSpeciesReferenceGlyphs self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ListOfSpeciesReferenceGlyphs
        __init__(ListOfSpeciesReferenceGlyphs self, unsigned int level, unsigned int version) -> ListOfSpeciesReferenceGlyphs
        __init__(ListOfSpeciesReferenceGlyphs self, unsigned int level) -> ListOfSpeciesReferenceGlyphs
        __init__(ListOfSpeciesReferenceGlyphs self) -> ListOfSpeciesReferenceGlyphs
        __init__(ListOfSpeciesReferenceGlyphs self, LayoutPkgNamespaces layoutns) -> ListOfSpeciesReferenceGlyphs


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfSpeciesReferenceGlyphs(LayoutPkgNamespaces layoutns)

        Constructor.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'layoutns' is the LayoutPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfSpeciesReferenceGlyphs(long level      =
        LayoutExtension.getDefaultLevel(), long version    =
        LayoutExtension.getDefaultVersion(), long pkgVersion =
        LayoutExtension.getDefaultPackageVersion())

        Constructor.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        this = _libsbml.new_ListOfSpeciesReferenceGlyphs(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfSpeciesReferenceGlyphs self) -> int


        Returns the libSBML type code for the SBML objects contained in this
        ListOf object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for objects contained in this list:
        SBML_LAYOUT_SPECIESREFERENCEGLYPH (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfSpeciesReferenceGlyphs_getItemTypeCode(self)


    def getElementName(self):
        """
        getElementName(ListOfSpeciesReferenceGlyphs self) -> string


        Returns the XML element name of this SBML object.

        Returns the string of the name of this element.

        """
        return _libsbml.ListOfSpeciesReferenceGlyphs_getElementName(self)


    def get(self, *args):
        """
        get(ListOfSpeciesReferenceGlyphs self, unsigned int n) -> SpeciesReferenceGlyph
        get(ListOfSpeciesReferenceGlyphs self, unsigned int n) -> SpeciesReferenceGlyph
        get(ListOfSpeciesReferenceGlyphs self, string sid) -> SpeciesReferenceGlyph
        get(ListOfSpeciesReferenceGlyphs self, string sid) -> SpeciesReferenceGlyph


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a SpeciesReferenceGlyph from the ListOfSpeciesReferenceGlyphs.

        Parameter 'n' is the index number of the SpeciesReferenceGlyph to get.

        Returns the nth SpeciesReferenceGlyph in this
        ListOfSpeciesReferenceGlyphs. If the index 'n' is invalid, 'None' is
        returned.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a SpeciesReferenceGlyph from the ListOfSpeciesReferenceGlyphs
        based on its identifier.

        Parameter 'sid' is a string representing the identifier  of the
        SpeciesReferenceGlyph to get.

        Returns SpeciesReferenceGlyph in this ListOfSpeciesReferenceGlyphs
        with the given 'sid' or 'None' if no such SpeciesReferenceGlyph
        exists.

        See also get(), size().

        """
        return _libsbml.ListOfSpeciesReferenceGlyphs_get(self, *args)


    def remove(self, *args):
        """
        remove(ListOfSpeciesReferenceGlyphs self, unsigned int n) -> SpeciesReferenceGlyph
        remove(ListOfSpeciesReferenceGlyphs self, string sid) -> SpeciesReferenceGlyph


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth item from this ListOfSpeciesReferenceGlyphs items and
        returns a pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the item to remove.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes item in this ListOfSpeciesReferenceGlyphs 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 'sid', then
        'None' is returned.

        Parameter 'sid' is the identifier of the item to remove.

        Returns the item removed.  As mentioned above, the caller owns the
        returned item.

        """
        return _libsbml.ListOfSpeciesReferenceGlyphs_remove(self, *args)


    def toXML(self):
        """
        toXML(ListOfSpeciesReferenceGlyphs self) -> XMLNode


        Creates an XMLNode object from this.

        """
        return _libsbml.ListOfSpeciesReferenceGlyphs_toXML(self)

    __swig_destroy__ = _libsbml.delete_ListOfSpeciesReferenceGlyphs
    __del__ = lambda self: None
ListOfSpeciesReferenceGlyphs_swigregister = _libsbml.ListOfSpeciesReferenceGlyphs_swigregister
ListOfSpeciesReferenceGlyphs_swigregister(ListOfSpeciesReferenceGlyphs)

class ReactionGlyph(GraphicalObject):
    """

    [SBML 'layout' package]

    A glyph for an SBML reaction.

    Analogous to how a Reaction object has to at least have one reactant
    or product, the ReactionGlyph has to at least have one
    SpeciesReferenceGlyph stored in the ListOfSpeciesReferenceGlyphs.
    Figure 12 on the following page provides the UML diagram for the class
    definition.  The ReactionGlyph inherits from GraphicalObject. In
    addition to the attributes inherited from GraphicalObject, the
    ReactionGlyph is described by an attribute reaction, a Curve element
    and a listOfSpeciesReferenceGlyphs element.  The Curve describes the
    center section of a ReactionGlyph. The center section is frequently
    used by tools to separate the point where substrates arcs come
    together, from the point where product arcs split off. The Curve is
    optional, and when not present the dimensions of the inherited
    BoundingBox describes the center section, by storing its position and
    dimension.

    """

    __swig_setmethods__ = {}
    for _s in [GraphicalObject]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ReactionGlyph, name, value)
    __swig_getmethods__ = {}
    for _s in [GraphicalObject]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ReactionGlyph, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ReactionGlyph self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ReactionGlyph
        __init__(ReactionGlyph self, unsigned int level, unsigned int version) -> ReactionGlyph
        __init__(ReactionGlyph self, unsigned int level) -> ReactionGlyph
        __init__(ReactionGlyph self) -> ReactionGlyph
        __init__(ReactionGlyph self, LayoutPkgNamespaces layoutns) -> ReactionGlyph
        __init__(ReactionGlyph self, LayoutPkgNamespaces layoutns, string id) -> ReactionGlyph
        __init__(ReactionGlyph self, LayoutPkgNamespaces layoutns, string id, string reactionId) -> ReactionGlyph
        __init__(ReactionGlyph self, XMLNode node, unsigned int l2version=4) -> ReactionGlyph
        __init__(ReactionGlyph self, XMLNode node) -> ReactionGlyph
        __init__(ReactionGlyph self, ReactionGlyph source) -> ReactionGlyph


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ReactionGlyph(ReactionGlyph source)

        Copy constructor.

        Parameter 'source' is the instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            ReactionGlyph(LayoutPkgNamespaces layoutns, string id, string
        reactionId)

        Creates a ResctionGlyph with the given LayoutPkgNamespaces, id and set
        the id of the associated reaction to the second argument.

        (FOR BACKWARD COMPATIBILITY)

        ______________________________________________________________________
        Method variant with the following signature:

            ReactionGlyph(long level      =
        LayoutExtension.getDefaultLevel(), long version    =
        LayoutExtension.getDefaultVersion(), long pkgVersion =
        LayoutExtension.getDefaultPackageVersion())

        Creates a new ReactionGlyph.  The list of species reference glyph is
        empty and the id of the associated reaction is set to the empty
        string.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            ReactionGlyph(XMLNode node, long l2version = 4)

        Creates a new ReactionGlyph from the given XMLNode

        (FOR BACKWARD COMPATIBILITY)

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            ReactionGlyph(LayoutPkgNamespaces layoutns)

        Creates a new ReactionGlyph with the given LayoutPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'layoutns' is the LayoutPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        ______________________________________________________________________
        Method variant with the following signature:

            ReactionGlyph(LayoutPkgNamespaces layoutns, string id)

        Creates a ResctionGlyph with the given LayoutPkgNamespaces and id.

        (FOR BACKWARD COMPATIBILITY)

        """
        this = _libsbml.new_ReactionGlyph(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_ReactionGlyph
    __del__ = lambda self: None

    def getReactionId(self):
        """
        getReactionId(ReactionGlyph self) -> string


        Returns the id of the associated reaction.

        """
        return _libsbml.ReactionGlyph_getReactionId(self)


    def setReactionId(self, id):
        """
        setReactionId(ReactionGlyph self, string id) -> int


        Sets the id of the associated reaction.

        """
        return _libsbml.ReactionGlyph_setReactionId(self, id)


    def isSetReactionId(self):
        """
        isSetReactionId(ReactionGlyph self) -> bool


        Returns 'True' if the id of the associated reaction is not the empty
        string.

        """
        return _libsbml.ReactionGlyph_isSetReactionId(self)


    def getListOfSpeciesReferenceGlyphs(self):
        """
        getListOfSpeciesReferenceGlyphs(ReactionGlyph self) -> ListOfSpeciesReferenceGlyphs


        Returns the ListOf object that hold the species reference glyphs.

        """
        return _libsbml.ReactionGlyph_getListOfSpeciesReferenceGlyphs(self)


    def getSpeciesReferenceGlyph(self, *args):
        """
        getSpeciesReferenceGlyph(ReactionGlyph self, unsigned int index) -> SpeciesReferenceGlyph
        getSpeciesReferenceGlyph(ReactionGlyph self, unsigned int index) -> SpeciesReferenceGlyph


        Returns the species reference glyph with the given 'index'. If the
        index is invalid, 'None' is returned.

        """
        return _libsbml.ReactionGlyph_getSpeciesReferenceGlyph(self, *args)


    def addSpeciesReferenceGlyph(self, glyph):
        """
        addSpeciesReferenceGlyph(ReactionGlyph self, SpeciesReferenceGlyph glyph) -> int


        Adds a new species reference glyph to the list.

        """
        return _libsbml.ReactionGlyph_addSpeciesReferenceGlyph(self, glyph)


    def getNumSpeciesReferenceGlyphs(self):
        """
        getNumSpeciesReferenceGlyphs(ReactionGlyph self) -> unsigned int


        Returns the number of species reference glyph objects.

        """
        return _libsbml.ReactionGlyph_getNumSpeciesReferenceGlyphs(self)


    def initDefaults(self):
        """
        initDefaults(ReactionGlyph self)


        Calls initDefaults from GraphicalObject.

        """
        return _libsbml.ReactionGlyph_initDefaults(self)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(ReactionGlyph self, string oldid, string newid)


        Replaces all uses of a given 'SIdRef' type attribute value with
        another value.

        In SBML, object identifiers are of a data type called SId. In SBML
        Level 3, an explicit data type called SIdRef was introduced for
        attribute values that refer to SId values; in previous Levels of SBML,
        this data type did not exist and attributes were simply described to
        as 'referring to an identifier', but the effective data type was the
        same as SIdRef in Level 3.  These and other methods of libSBML refer
        to the type SIdRef for all Levels of SBML, even if the corresponding
        SBML specification did not explicitly name the data type.

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas in MathML content, comparing the referenced
        identifiers to the value of 'oldid'.  If any matches are found, the
        matching values are replaced with 'newid'.  The method does not
        descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.ReactionGlyph_renameSIdRefs(self, oldid, newid)


    def getCurve(self, *args):
        """
        getCurve(ReactionGlyph self) -> Curve
        getCurve(ReactionGlyph self) -> Curve


        Returns the curve object for the reaction glyph

        """
        return _libsbml.ReactionGlyph_getCurve(self, *args)


    def setCurve(self, curve):
        """
        setCurve(ReactionGlyph self, Curve curve)


        Sets the curve object for the reaction glyph.

        """
        return _libsbml.ReactionGlyph_setCurve(self, curve)


    def isSetCurve(self):
        """
        isSetCurve(ReactionGlyph self) -> bool


        Returns 'True' if the curve consists of one or more segments.

        """
        return _libsbml.ReactionGlyph_isSetCurve(self)


    def getCurveExplicitlySet(self):
        """
        getCurveExplicitlySet(ReactionGlyph self) -> bool




        """
        return _libsbml.ReactionGlyph_getCurveExplicitlySet(self)


    def createSpeciesReferenceGlyph(self):
        """
        createSpeciesReferenceGlyph(ReactionGlyph self) -> SpeciesReferenceGlyph


        Creates a new SpeciesReferenceGlyph object, adds it to the end of the
        list of species reference objects and returns a reference to the newly
        created object.

        """
        return _libsbml.ReactionGlyph_createSpeciesReferenceGlyph(self)


    def createLineSegment(self):
        """
        createLineSegment(ReactionGlyph self) -> LineSegment


        Creates a new LineSegment object, adds it to the end of the list of
        curve segment objects of the curve and returns a reference to the
        newly created object.

        """
        return _libsbml.ReactionGlyph_createLineSegment(self)


    def createCubicBezier(self):
        """
        createCubicBezier(ReactionGlyph self) -> CubicBezier


        Creates a new CubicBezier object, adds it to the end of the list of
        curve segment objects of the curve and returns a reference to the
        newly created object.

        """
        return _libsbml.ReactionGlyph_createCubicBezier(self)


    def removeSpeciesReferenceGlyph(self, *args):
        """
        removeSpeciesReferenceGlyph(ReactionGlyph self, unsigned int index) -> SpeciesReferenceGlyph
        removeSpeciesReferenceGlyph(ReactionGlyph self, string id) -> SpeciesReferenceGlyph


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeSpeciesReferenceGlyph(long index)

        Remove the species reference glyph with the given 'index'. A pointer
        to the object is returned. If no object has been removed, None is
        returned.

        ______________________________________________________________________
        Method variant with the following signature:

            removeSpeciesReferenceGlyph(string id)

        Remove the species reference glyph with the given 'id'. A pointer to
        the object is returned. If no object has been removed, None is
        returned.

        """
        return _libsbml.ReactionGlyph_removeSpeciesReferenceGlyph(self, *args)


    def getIndexForSpeciesReferenceGlyph(self, id):
        """
        getIndexForSpeciesReferenceGlyph(ReactionGlyph self, string id) -> unsigned int


        Returns the index of the species reference glyph with the given 'id'.
        If the reaction glyph does not contain a species reference glyph with
        this id, the value of the maximum long integer is returned as an
        indicator.

        """
        return _libsbml.ReactionGlyph_getIndexForSpeciesReferenceGlyph(self, id)


    def getElementName(self):
        """
        getElementName(ReactionGlyph self) -> string


        Returns the XML element name of this SBML object.

        Returns the string of the name of this element.

        """
        return _libsbml.ReactionGlyph_getElementName(self)


    def clone(self):
        """
        clone(ReactionGlyph self) -> ReactionGlyph


        Creates and returns a deep copy of this ReactionGlyph object.

        Returns a (deep) copy of this ReactionGlyph.

        """
        return _libsbml.ReactionGlyph_clone(self)


    def getTypeCode(self):
        """
        getTypeCode(ReactionGlyph self) -> int


        Returns the libSBML type code of this object instance.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_LAYOUT_REACTIONGLYPH.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ReactionGlyph_getTypeCode(self)


    def toXML(self):
        """
        toXML(ReactionGlyph self) -> XMLNode


        Creates an XMLNode object from this.

        """
        return _libsbml.ReactionGlyph_toXML(self)


    def connectToChild(self):
        """connectToChild(ReactionGlyph self)"""
        return _libsbml.ReactionGlyph_connectToChild(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(ReactionGlyph self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.ReactionGlyph_enablePackageInternal(self, pkgURI, pkgPrefix, flag)

ReactionGlyph_swigregister = _libsbml.ReactionGlyph_swigregister
ReactionGlyph_swigregister(ReactionGlyph)

class SpeciesGlyph(GraphicalObject):
    """

    [SBML 'layout' package]

    A glyph for an SBML species.

    In addition to the attributes it inherits from GraphicalObject, the
    SpeciesGlyph object has an optional 'species' attribute.

    """

    __swig_setmethods__ = {}
    for _s in [GraphicalObject]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SpeciesGlyph, name, value)
    __swig_getmethods__ = {}
    for _s in [GraphicalObject]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SpeciesGlyph, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(SpeciesGlyph self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> SpeciesGlyph
        __init__(SpeciesGlyph self, unsigned int level, unsigned int version) -> SpeciesGlyph
        __init__(SpeciesGlyph self, unsigned int level) -> SpeciesGlyph
        __init__(SpeciesGlyph self) -> SpeciesGlyph
        __init__(SpeciesGlyph self, LayoutPkgNamespaces layoutns) -> SpeciesGlyph
        __init__(SpeciesGlyph self, LayoutPkgNamespaces layoutns, string id) -> SpeciesGlyph
        __init__(SpeciesGlyph self, LayoutPkgNamespaces layoutns, string id, string speciesId) -> SpeciesGlyph
        __init__(SpeciesGlyph self, XMLNode node, unsigned int l2version=4) -> SpeciesGlyph
        __init__(SpeciesGlyph self, XMLNode node) -> SpeciesGlyph
        __init__(SpeciesGlyph self, SpeciesGlyph source) -> SpeciesGlyph


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            SpeciesGlyph(XMLNode node, long l2version=4)

        Creates a new SpeciesGlyph from the given XMLNode

        ______________________________________________________________________
        Method variant with the following signature:

            SpeciesGlyph(long level      =
        LayoutExtension.getDefaultLevel(), long version    =
        LayoutExtension.getDefaultVersion(), long pkgVersion =
        LayoutExtension.getDefaultPackageVersion())

        Creates a new SpeciesGlyph with the given SBML level, version, and
        package version and the id of the associated species set to the empty
        string.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            SpeciesGlyph(LayoutPkgNamespaces layoutns, string id, string
        speciesId)

        Creates a new SpeciesGlyph with the given 'id' and the id of the
        associated species object set to the second argument.

        (FOR BACKWARD COMPATIBILITY)

        ______________________________________________________________________
        Method variant with the following signature:

            SpeciesGlyph(LayoutPkgNamespaces layoutns)

        Constructor.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'layoutns' is the LayoutPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        ______________________________________________________________________
        Method variant with the following signature:

            SpeciesGlyph(SpeciesGlyph source)

        Copy constructor.

        Parameter 'source' is the instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            SpeciesGlyph(LayoutPkgNamespaces layoutns, string id)

        Creates a new SpeciesGlyph with the given 'id'.

        (FOR BACKWARD COMPATIBILITY)

        """
        this = _libsbml.new_SpeciesGlyph(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_SpeciesGlyph
    __del__ = lambda self: None

    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(SpeciesGlyph self, string oldid, string newid)


        Replaces all uses of a given 'SIdRef' type attribute value with
        another value.

        In SBML, object identifiers are of a data type called SId. In SBML
        Level 3, an explicit data type called SIdRef was introduced for
        attribute values that refer to SId values; in previous Levels of SBML,
        this data type did not exist and attributes were simply described to
        as 'referring to an identifier', but the effective data type was the
        same as SIdRef in Level 3.  These and other methods of libSBML refer
        to the type SIdRef for all Levels of SBML, even if the corresponding
        SBML specification did not explicitly name the data type.

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas in MathML content, comparing the referenced
        identifiers to the value of 'oldid'.  If any matches are found, the
        matching values are replaced with 'newid'.  The method does not
        descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.SpeciesGlyph_renameSIdRefs(self, oldid, newid)


    def getSpeciesId(self):
        """
        getSpeciesId(SpeciesGlyph self) -> string


        Returns the id of the associated species object.

        """
        return _libsbml.SpeciesGlyph_getSpeciesId(self)


    def setSpeciesId(self, id):
        """
        setSpeciesId(SpeciesGlyph self, string id)


        Sets the id of the associated species object.

        """
        return _libsbml.SpeciesGlyph_setSpeciesId(self, id)


    def isSetSpeciesId(self):
        """
        isSetSpeciesId(SpeciesGlyph self) -> bool


        Returns 'True' if the id of the associated species object is not the
        empty string.

        """
        return _libsbml.SpeciesGlyph_isSetSpeciesId(self)


    def initDefaults(self):
        """
        initDefaults(SpeciesGlyph self)


        Calls initDefaults from GraphicalObject.

        """
        return _libsbml.SpeciesGlyph_initDefaults(self)


    def getElementName(self):
        """
        getElementName(SpeciesGlyph self) -> string


        Returns the XML element name of this SBML object.

        Returns the string of the name of this element.

        """
        return _libsbml.SpeciesGlyph_getElementName(self)


    def clone(self):
        """
        clone(SpeciesGlyph self) -> SpeciesGlyph


        Creates and returns a deep copy of this SpeciesGlyph.

        Returns a (deep) copy of this SpeciesGlyph.

        """
        return _libsbml.SpeciesGlyph_clone(self)


    def getTypeCode(self):
        """
        getTypeCode(SpeciesGlyph self) -> int


        Returns the libSBML type code of this object instance.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_LAYOUT_SPECIESGLYPH.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.SpeciesGlyph_getTypeCode(self)


    def toXML(self):
        """
        toXML(SpeciesGlyph self) -> XMLNode


        Creates an XMLNode object from this.

        """
        return _libsbml.SpeciesGlyph_toXML(self)

SpeciesGlyph_swigregister = _libsbml.SpeciesGlyph_swigregister
SpeciesGlyph_swigregister(SpeciesGlyph)

class TextGlyph(GraphicalObject):
    """

    [SBML 'layout' package]

    A glyph for a text label.

    The TextGlyph class describes the position and dimension of text
    labels in the "layout" package.  It inherits from GraphicalObject
    and adds the attributes graphicalObject, text and originOfText.

    """

    __swig_setmethods__ = {}
    for _s in [GraphicalObject]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TextGlyph, name, value)
    __swig_getmethods__ = {}
    for _s in [GraphicalObject]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, TextGlyph, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(TextGlyph self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> TextGlyph
        __init__(TextGlyph self, unsigned int level, unsigned int version) -> TextGlyph
        __init__(TextGlyph self, unsigned int level) -> TextGlyph
        __init__(TextGlyph self) -> TextGlyph
        __init__(TextGlyph self, LayoutPkgNamespaces layoutns) -> TextGlyph
        __init__(TextGlyph self, LayoutPkgNamespaces layoutns, string id) -> TextGlyph
        __init__(TextGlyph self, LayoutPkgNamespaces layoutns, string id, string text) -> TextGlyph
        __init__(TextGlyph self, XMLNode node, unsigned int l2version=4) -> TextGlyph
        __init__(TextGlyph self, XMLNode node) -> TextGlyph
        __init__(TextGlyph self, TextGlyph source) -> TextGlyph


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            TextGlyph(XMLNode node, long l2version=4)

        Creates a new TextGlyph from the given XMLNode

        (FOR BACKWARD COMPATIBILITY)

        ______________________________________________________________________
        Method variant with the following signature:

            TextGlyph(long level      =
        LayoutExtension.getDefaultLevel(), long version    =
        LayoutExtension.getDefaultVersion(), long pkgVersion =
        LayoutExtension.getDefaultPackageVersion())

        Creates a new TextGlyph with the given SBML level, versin and package
        version. The ids of the associated GraphicalObject and the
        originOfText are set to the empty string. The actual text is set to
        the empty string as well.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            TextGlyph(LayoutPkgNamespaces layoutns, string id, string
        text)

        Creates a new TextGlyph. The id is given as the first argument, the
        text to be displayed as the second.  All other attirbutes are set to
        the empty string.

        (FOR BACKWARD COMPATIBILITY)

        ______________________________________________________________________
        Method variant with the following signature:

            TextGlyph(LayoutPkgNamespaces layoutns)

        Constructor.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'layoutns' is the LayoutPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        ______________________________________________________________________
        Method variant with the following signature:

            TextGlyph(TextGlyph source)

        Copy constructor.

        Parameter 'source' is the instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            TextGlyph(LayoutPkgNamespaces layoutns, string id)

        Creates a new TextGlyph. The id is given as the first argument.

        (FOR BACKWARD COMPATIBILITY)

        """
        this = _libsbml.new_TextGlyph(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_TextGlyph
    __del__ = lambda self: None

    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(TextGlyph self, string oldid, string newid)


        Replaces all uses of a given 'SIdRef' type attribute value with
        another value.

        In SBML, object identifiers are of a data type called SId. In SBML
        Level 3, an explicit data type called SIdRef was introduced for
        attribute values that refer to SId values; in previous Levels of SBML,
        this data type did not exist and attributes were simply described to
        as 'referring to an identifier', but the effective data type was the
        same as SIdRef in Level 3.  These and other methods of libSBML refer
        to the type SIdRef for all Levels of SBML, even if the corresponding
        SBML specification did not explicitly name the data type.

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas in MathML content, comparing the referenced
        identifiers to the value of 'oldid'.  If any matches are found, the
        matching values are replaced with 'newid'.  The method does not
        descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.TextGlyph_renameSIdRefs(self, oldid, newid)


    def getText(self):
        """
        getText(TextGlyph self) -> string


        Returns the text to be displayed by the text glyph.

        """
        return _libsbml.TextGlyph_getText(self)


    def setText(self, text):
        """
        setText(TextGlyph self, string text)


        Sets the text to be displayed by the text glyph.

        """
        return _libsbml.TextGlyph_setText(self, text)


    def getGraphicalObjectId(self):
        """
        getGraphicalObjectId(TextGlyph self) -> string


        Returns the id of the associated graphical object.

        """
        return _libsbml.TextGlyph_getGraphicalObjectId(self)


    def setGraphicalObjectId(self, id):
        """
        setGraphicalObjectId(TextGlyph self, string id) -> int


        Sets the id of the associated graphical object.

        """
        return _libsbml.TextGlyph_setGraphicalObjectId(self, id)


    def getOriginOfTextId(self):
        """
        getOriginOfTextId(TextGlyph self) -> string


        Returns the id of the origin of text.

        """
        return _libsbml.TextGlyph_getOriginOfTextId(self)


    def setOriginOfTextId(self, orig):
        """
        setOriginOfTextId(TextGlyph self, string orig) -> int


        Sets the id of the origin of text.

        """
        return _libsbml.TextGlyph_setOriginOfTextId(self, orig)


    def isSetText(self):
        """
        isSetText(TextGlyph self) -> bool


        Returns 'True' if the text is not the empty string.

        """
        return _libsbml.TextGlyph_isSetText(self)


    def isSetOriginOfTextId(self):
        """
        isSetOriginOfTextId(TextGlyph self) -> bool


        Returns 'True' if the id of the origin of text is not the empty
        string.

        """
        return _libsbml.TextGlyph_isSetOriginOfTextId(self)


    def isSetGraphicalObjectId(self):
        """
        isSetGraphicalObjectId(TextGlyph self) -> bool


        Returns 'True' if the id of the associated graphical object is not the
        empty string.

        """
        return _libsbml.TextGlyph_isSetGraphicalObjectId(self)


    def initDefaults(self):
        """
        initDefaults(TextGlyph self)


        Calls initDefaults from GraphicalObject.

        """
        return _libsbml.TextGlyph_initDefaults(self)


    def getElementName(self):
        """
        getElementName(TextGlyph self) -> string


        Returns the XML element name of this SBML object.

        Returns the string of the name of this element.

        """
        return _libsbml.TextGlyph_getElementName(self)


    def clone(self):
        """
        clone(TextGlyph self) -> TextGlyph


        Creates and returns a deep copy of this TextGlyph.

        Returns a (deep) copy of this TextGlyph.

        """
        return _libsbml.TextGlyph_clone(self)


    def getTypeCode(self):
        """
        getTypeCode(TextGlyph self) -> int


        Returns the libSBML type code of this object instance.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_LAYOUT_TEXTGLYPH.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.TextGlyph_getTypeCode(self)


    def toXML(self):
        """
        toXML(TextGlyph self) -> XMLNode


        Creates an XMLNode object from this.

        """
        return _libsbml.TextGlyph_toXML(self)

TextGlyph_swigregister = _libsbml.TextGlyph_swigregister
TextGlyph_swigregister(TextGlyph)

class ListOfCompartmentGlyphs(ListOf):
    """

    [SBML 'layout' package]

    A list of CompartmentGlyph objects.

    The ListOfCompartmentGlyphs is a container for the CompartmentGlyph
    elements of a Layout.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    See also CompartmentGlyph.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfCompartmentGlyphs, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfCompartmentGlyphs, name)
    __repr__ = _swig_repr

    def clone(self):
        """
        clone(ListOfCompartmentGlyphs self) -> ListOfCompartmentGlyphs


        Creates and returns a deep copy of this ListOfCompartmentGlyphs.

        Returns a (deep) copy of this ListOfCompartmentGlyphs.

        """
        return _libsbml.ListOfCompartmentGlyphs_clone(self)


    def __init__(self, *args):
        """
        __init__(ListOfCompartmentGlyphs self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ListOfCompartmentGlyphs
        __init__(ListOfCompartmentGlyphs self, unsigned int level, unsigned int version) -> ListOfCompartmentGlyphs
        __init__(ListOfCompartmentGlyphs self, unsigned int level) -> ListOfCompartmentGlyphs
        __init__(ListOfCompartmentGlyphs self) -> ListOfCompartmentGlyphs
        __init__(ListOfCompartmentGlyphs self, LayoutPkgNamespaces layoutns) -> ListOfCompartmentGlyphs


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfCompartmentGlyphs(LayoutPkgNamespaces layoutns)

        Constructor.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'layoutns' is the LayoutPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfCompartmentGlyphs(long level      =
        LayoutExtension.getDefaultLevel(), long version    =
        LayoutExtension.getDefaultVersion(), long pkgVersion =
        LayoutExtension.getDefaultPackageVersion())

        Constructor.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        this = _libsbml.new_ListOfCompartmentGlyphs(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfCompartmentGlyphs self) -> int


        Returns the libSBML type code for the SBML objects contained in this
        ListOf object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for objects contained in this list:
        SBML_LAYOUT_COMPARTMENTGLYPH (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfCompartmentGlyphs_getItemTypeCode(self)


    def getElementName(self):
        """
        getElementName(ListOfCompartmentGlyphs self) -> string


        Returns the XML element name of this SBML object.

        Returns the string of the name of this element.

        """
        return _libsbml.ListOfCompartmentGlyphs_getElementName(self)


    def toXML(self):
        """
        toXML(ListOfCompartmentGlyphs self) -> XMLNode


        Creates an XMLNode object from this.

        """
        return _libsbml.ListOfCompartmentGlyphs_toXML(self)


    def get(self, *args):
        """
        get(ListOfCompartmentGlyphs self, unsigned int n) -> CompartmentGlyph
        get(ListOfCompartmentGlyphs self, unsigned int n) -> CompartmentGlyph
        get(ListOfCompartmentGlyphs self, string sid) -> CompartmentGlyph
        get(ListOfCompartmentGlyphs self, string sid) -> CompartmentGlyph


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a CompartmentGlyph from the ListOfCompartmentGlyphs.

        Parameter 'n' is the index number of the CompartmentGlyph to get.

        Returns the nth CompartmentGlyph in this ListOfCompartmentGlyphs. If
        the index 'n' is invalid, 'None' is returned.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a CompartmentGlyph from the ListOfCompartmentGlyphs based on its
        identifier.

        Parameter 'sid' is a string representing the identifier  of the
        CompartmentGlyph to get.

        Returns CompartmentGlyph in this ListOfCompartmentGlyphs with the
        given 'sid' or 'None' if no such CompartmentGlyph exists.

        See also get(), size().

        """
        return _libsbml.ListOfCompartmentGlyphs_get(self, *args)


    def remove(self, *args):
        """
        remove(ListOfCompartmentGlyphs self, unsigned int n) -> CompartmentGlyph
        remove(ListOfCompartmentGlyphs self, string sid) -> CompartmentGlyph


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth item from this ListOfCompartmentGlyphs items and
        returns a pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the item to remove.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes item in this ListOfCompartmentGlyphs 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 'sid', then
        'None' is returned.

        Parameter 'sid' is the identifier of the item to remove.

        Returns the item removed.  As mentioned above, the caller owns the
        returned item.

        """
        return _libsbml.ListOfCompartmentGlyphs_remove(self, *args)

    __swig_destroy__ = _libsbml.delete_ListOfCompartmentGlyphs
    __del__ = lambda self: None
ListOfCompartmentGlyphs_swigregister = _libsbml.ListOfCompartmentGlyphs_swigregister
ListOfCompartmentGlyphs_swigregister(ListOfCompartmentGlyphs)

class ListOfSpeciesGlyphs(ListOf):
    """

    [SBML 'layout' package]

    A list of SpeciesGlyph objects.

    The ListOfSpeciesGlyphs is a container for the SpeciesGlyph elements
    of a Layout.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    See also SpeciesGlyph.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfSpeciesGlyphs, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfSpeciesGlyphs, name)
    __repr__ = _swig_repr

    def clone(self):
        """
        clone(ListOfSpeciesGlyphs self) -> ListOfSpeciesGlyphs


        Creates and returns a deep copy of this ListOfSpeciesGlyphs.

        Returns a (deep) copy of this ListOfSpeciesGlyphs.

        """
        return _libsbml.ListOfSpeciesGlyphs_clone(self)


    def __init__(self, *args):
        """
        __init__(ListOfSpeciesGlyphs self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ListOfSpeciesGlyphs
        __init__(ListOfSpeciesGlyphs self, unsigned int level, unsigned int version) -> ListOfSpeciesGlyphs
        __init__(ListOfSpeciesGlyphs self, unsigned int level) -> ListOfSpeciesGlyphs
        __init__(ListOfSpeciesGlyphs self) -> ListOfSpeciesGlyphs
        __init__(ListOfSpeciesGlyphs self, LayoutPkgNamespaces layoutns) -> ListOfSpeciesGlyphs


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfSpeciesGlyphs(LayoutPkgNamespaces layoutns)

        Constructor.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'layoutns' is the LayoutPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfSpeciesGlyphs(long level      =
        LayoutExtension.getDefaultLevel(), long version    =
        LayoutExtension.getDefaultVersion(), long pkgVersion =
        LayoutExtension.getDefaultPackageVersion())

        Constructor.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        this = _libsbml.new_ListOfSpeciesGlyphs(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfSpeciesGlyphs self) -> int


        Returns the libSBML type code for the SBML objects contained in this
        ListOf object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for objects contained in this list:
        SBML_LAYOUT_SPECIESGLYPH (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfSpeciesGlyphs_getItemTypeCode(self)


    def getElementName(self):
        """
        getElementName(ListOfSpeciesGlyphs self) -> string


        Returns the XML element name of this SBML object.

        Returns the string of the name of this element.

        """
        return _libsbml.ListOfSpeciesGlyphs_getElementName(self)


    def get(self, *args):
        """
        get(ListOfSpeciesGlyphs self, unsigned int n) -> SpeciesGlyph
        get(ListOfSpeciesGlyphs self, unsigned int n) -> SpeciesGlyph
        get(ListOfSpeciesGlyphs self, string sid) -> SpeciesGlyph
        get(ListOfSpeciesGlyphs self, string sid) -> SpeciesGlyph


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a SpeciesGlyph from the ListOfSpeciesGlyphs.

        Parameter 'n' is the index number of the SpeciesGlyph to get.

        Returns the nth SpeciesGlyph in this ListOfSpeciesGlyphs. If the index
        'n' is invalid, 'None' is returned.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a SpeciesGlyph from the ListOfSpeciesGlyphs based on its
        identifier.

        Parameter 'sid' is a string representing the identifier  of the
        SpeciesGlyph to get.

        Returns SpeciesGlyph in this ListOfSpeciesGlyphs with the given 'sid'
        or 'None' if no such SpeciesGlyph exists.

        See also get(), size().

        """
        return _libsbml.ListOfSpeciesGlyphs_get(self, *args)


    def remove(self, *args):
        """
        remove(ListOfSpeciesGlyphs self, unsigned int n) -> SpeciesGlyph
        remove(ListOfSpeciesGlyphs self, string sid) -> SpeciesGlyph


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth item from this ListOfSpeciesGlyphs items and returns a
        pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the item to remove.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes item in this ListOfSpeciesGlyphs 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 'sid', then
        'None' is returned.

        Parameter 'sid' is the identifier of the item to remove.

        Returns the item removed.  As mentioned above, the caller owns the
        returned item.

        """
        return _libsbml.ListOfSpeciesGlyphs_remove(self, *args)


    def toXML(self):
        """
        toXML(ListOfSpeciesGlyphs self) -> XMLNode


        Creates an XMLNode object from this.

        """
        return _libsbml.ListOfSpeciesGlyphs_toXML(self)

    __swig_destroy__ = _libsbml.delete_ListOfSpeciesGlyphs
    __del__ = lambda self: None
ListOfSpeciesGlyphs_swigregister = _libsbml.ListOfSpeciesGlyphs_swigregister
ListOfSpeciesGlyphs_swigregister(ListOfSpeciesGlyphs)

class ListOfReactionGlyphs(ListOf):
    """

    [SBML 'layout' package]

    A list of ReactionGlyph objects.

    The ListOfReactionGlyphs is a container for the ReactionGlyph elements
    of a Layout.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    See also ReactionGlyph.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfReactionGlyphs, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfReactionGlyphs, name)
    __repr__ = _swig_repr

    def clone(self):
        """
        clone(ListOfReactionGlyphs self) -> ListOfReactionGlyphs


        Creates and returns a deep copy of this ListOfReactionGlyphs.

        Returns a (deep) copy of this ListOfReactionGlyphs.

        """
        return _libsbml.ListOfReactionGlyphs_clone(self)


    def __init__(self, *args):
        """
        __init__(ListOfReactionGlyphs self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ListOfReactionGlyphs
        __init__(ListOfReactionGlyphs self, unsigned int level, unsigned int version) -> ListOfReactionGlyphs
        __init__(ListOfReactionGlyphs self, unsigned int level) -> ListOfReactionGlyphs
        __init__(ListOfReactionGlyphs self) -> ListOfReactionGlyphs
        __init__(ListOfReactionGlyphs self, LayoutPkgNamespaces layoutns) -> ListOfReactionGlyphs


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfReactionGlyphs(LayoutPkgNamespaces layoutns)

        Constructor.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'layoutns' is the LayoutPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfReactionGlyphs(long level      =
        LayoutExtension.getDefaultLevel(), long version    =
        LayoutExtension.getDefaultVersion(), long pkgVersion =
        LayoutExtension.getDefaultPackageVersion())

        Constructor.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        this = _libsbml.new_ListOfReactionGlyphs(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfReactionGlyphs self) -> int


        Returns the libSBML type code for the SBML objects contained in this
        ListOf object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for objects contained in this list:
        SBML_LAYOUT_REACTIONGLYPH (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfReactionGlyphs_getItemTypeCode(self)


    def getElementName(self):
        """
        getElementName(ListOfReactionGlyphs self) -> string


        Returns the XML element name of this SBML object.

        Returns the string of the name of this element.

        """
        return _libsbml.ListOfReactionGlyphs_getElementName(self)


    def get(self, *args):
        """
        get(ListOfReactionGlyphs self, unsigned int n) -> ReactionGlyph
        get(ListOfReactionGlyphs self, unsigned int n) -> ReactionGlyph
        get(ListOfReactionGlyphs self, string sid) -> ReactionGlyph
        get(ListOfReactionGlyphs self, string sid) -> ReactionGlyph


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a ReactionGlyph from the ListOfReactionGlyphs.

        Parameter 'n' is the index number of the ReactionGlyph to get.

        Returns the nth ReactionGlyph in this ListOfReactionGlyphs. If the
        index 'n' is invalid, 'None' is returned.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a ReactionGlyph from the ListOfReactionGlyphs based on its
        identifier.

        Parameter 'sid' is a string representing the identifier  of the
        ReactionGlyph to get.

        Returns ReactionGlyph in this ListOfReactionGlyphs with the given
        'sid' or 'None' if no such ReactionGlyph exists.

        See also get(), size().

        """
        return _libsbml.ListOfReactionGlyphs_get(self, *args)


    def remove(self, *args):
        """
        remove(ListOfReactionGlyphs self, unsigned int n) -> ReactionGlyph
        remove(ListOfReactionGlyphs self, string sid) -> ReactionGlyph


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth item from this ListOfReactionGlyphs items and returns
        a pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the item to remove.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes item in this ListOfReactionGlyphs 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 'sid', then
        'None' is returned.

        Parameter 'sid' is the identifier of the item to remove.

        Returns the item removed.  As mentioned above, the caller owns the
        returned item.

        """
        return _libsbml.ListOfReactionGlyphs_remove(self, *args)


    def toXML(self):
        """
        toXML(ListOfReactionGlyphs self) -> XMLNode


        Creates an XMLNode object from this.

        """
        return _libsbml.ListOfReactionGlyphs_toXML(self)

    __swig_destroy__ = _libsbml.delete_ListOfReactionGlyphs
    __del__ = lambda self: None
ListOfReactionGlyphs_swigregister = _libsbml.ListOfReactionGlyphs_swigregister
ListOfReactionGlyphs_swigregister(ListOfReactionGlyphs)

class ListOfTextGlyphs(ListOf):
    """

    [SBML 'layout' package]

    A list of TextGlyph objects.

    The ListOfTextGlyphs is a container for the TextGlyph elements of a
    Layout.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    See also TextGlyph.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfTextGlyphs, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfTextGlyphs, name)
    __repr__ = _swig_repr

    def clone(self):
        """
        clone(ListOfTextGlyphs self) -> ListOfTextGlyphs


        Creates and returns a deep copy of this ListOfTextGlyphs.

        Returns a (deep) copy of this ListOfTextGlyphs.

        """
        return _libsbml.ListOfTextGlyphs_clone(self)


    def __init__(self, *args):
        """
        __init__(ListOfTextGlyphs self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ListOfTextGlyphs
        __init__(ListOfTextGlyphs self, unsigned int level, unsigned int version) -> ListOfTextGlyphs
        __init__(ListOfTextGlyphs self, unsigned int level) -> ListOfTextGlyphs
        __init__(ListOfTextGlyphs self) -> ListOfTextGlyphs
        __init__(ListOfTextGlyphs self, LayoutPkgNamespaces layoutns) -> ListOfTextGlyphs


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfTextGlyphs(LayoutPkgNamespaces layoutns)

        Constructor.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'layoutns' is the LayoutPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfTextGlyphs(long level      =
        LayoutExtension.getDefaultLevel(), long version    =
        LayoutExtension.getDefaultVersion(), long pkgVersion =
        LayoutExtension.getDefaultPackageVersion())

        Constructor.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        this = _libsbml.new_ListOfTextGlyphs(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfTextGlyphs self) -> int


        Returns the libSBML type code for the SBML objects contained in this
        ListOf object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for objects contained in this list:
        SBML_LAYOUT_TEXTGLYPH (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfTextGlyphs_getItemTypeCode(self)


    def getElementName(self):
        """
        getElementName(ListOfTextGlyphs self) -> string


        Returns the XML element name of this SBML object.

        Returns the string of the name of this element.

        """
        return _libsbml.ListOfTextGlyphs_getElementName(self)


    def get(self, *args):
        """
        get(ListOfTextGlyphs self, unsigned int n) -> TextGlyph
        get(ListOfTextGlyphs self, unsigned int n) -> TextGlyph
        get(ListOfTextGlyphs self, string sid) -> TextGlyph
        get(ListOfTextGlyphs self, string sid) -> TextGlyph


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a TextGlyph from the ListOfTextGlyphs.

        Parameter 'n' is the index number of the TextGlyph to get.

        Returns the nth TextGlyph in this ListOfTextGlyphs. If the index 'n'
        is invalid, 'None' is returned.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a TextGlyph from the ListOfTextGlyphs based on its identifier.

        Parameter 'sid' is a string representing the identifier  of the
        TextGlyph to get.

        Returns TextGlyph in this ListOfTextGlyphs with the given 'sid' or
        'None' if no such TextGlyph exists.

        See also get(), size().

        """
        return _libsbml.ListOfTextGlyphs_get(self, *args)


    def remove(self, *args):
        """
        remove(ListOfTextGlyphs self, unsigned int n) -> TextGlyph
        remove(ListOfTextGlyphs self, string sid) -> TextGlyph


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth item from this ListOfTextGlyphs items and returns a
        pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the item to remove.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes item in this ListOfTextGlyphs 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 'sid', then
        'None' is returned.

        Parameter 'sid' is the identifier of the item to remove.

        Returns the item removed.  As mentioned above, the caller owns the
        returned item.

        """
        return _libsbml.ListOfTextGlyphs_remove(self, *args)


    def toXML(self):
        """
        toXML(ListOfTextGlyphs self) -> XMLNode


        Creates an XMLNode object from this.

        """
        return _libsbml.ListOfTextGlyphs_toXML(self)

    __swig_destroy__ = _libsbml.delete_ListOfTextGlyphs
    __del__ = lambda self: None
ListOfTextGlyphs_swigregister = _libsbml.ListOfTextGlyphs_swigregister
ListOfTextGlyphs_swigregister(ListOfTextGlyphs)

class Layout(SBase):
    """

    [SBML 'layout' package]

    The layout of a diagram of an SBML model.

    The Layout class stores layout information for some or all elements of
    the SBML model as well as additional objects that need not be
    connected to the model. The Layout has two attributes: id and name.
    Additionally, a Dimensions element specifies the size of the layout.
    The actual layout elements are contained in several lists, namely: a
    ListOfCompartmentGlyphs, a ListOfSpeciesGlyphs, a
    ListOfReactionGlyphs, a ListOfTextGlyphs, and a
    ListOfAdditionalGraphicalObjects. Each of these lists can only occur
    once, and, if present, are not allowed to be empty.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Layout, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Layout, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(Layout self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> Layout
        __init__(Layout self, unsigned int level, unsigned int version) -> Layout
        __init__(Layout self, unsigned int level) -> Layout
        __init__(Layout self) -> Layout
        __init__(Layout self, LayoutPkgNamespaces layoutns) -> Layout
        __init__(Layout self, LayoutPkgNamespaces layoutns, string id, Dimensions dimensions) -> Layout
        __init__(Layout self, XMLNode node, unsigned int l2version=4) -> Layout
        __init__(Layout self, XMLNode node) -> Layout
        __init__(Layout self, Layout source) -> Layout


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            Layout(Layout source)

        Copy constructor.

        Parameter 'source' is the instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            Layout(LayoutPkgNamespaces layoutns)

        Creates a new Layout with the given LayoutPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'layoutns' is the LayoutPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        ______________________________________________________________________
        Method variant with the following signature:

            Layout(LayoutPkgNamespaces layoutns, string id, Dimensions
        dimensions)

        Creates a new Layout with the given 'id' and dimensions.

        (FOR BACKWARD COMPATIBILITY)

        ______________________________________________________________________
        Method variant with the following signature:

            Layout(long level      = LayoutExtension.getDefaultLevel(),
        long version    = LayoutExtension.getDefaultVersion(), long pkgVersion
        = LayoutExtension.getDefaultPackageVersion())

        Creates a new Layout with the given level, version, and package
        version.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            Layout(XMLNode node, long l2version = 4)

        Creates a new Layout from the given XMLNode (only for SBML Level2)

        (FOR BACKWARD COMPATIBILITY)

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        this = _libsbml.new_Layout(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_Layout
    __del__ = lambda self: None

    def initDefaults(self):
        """
        initDefaults(Layout self)


        Does nothing since no defaults are defined for Layout.

        """
        return _libsbml.Layout_initDefaults(self)


    def getId(self):
        """
        getId(Layout self) -> string


        Returns the value of the 'id' attribute of this Layout.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns the id of this Layout.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is now recommended to use the
        getIdAttribute() function instead.

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.Layout_getId(self)


    def isSetId(self):
        """
        isSetId(Layout self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        Layout's 'id' attribute has been set.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns 'True' if the 'id' attribute of this SBML object is set,
        'False' otherwise.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is recommended that callers use
        isSetIdAttribute() instead.

        See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(),
        isSetIdAttribute().

        """
        return _libsbml.Layout_isSetId(self)


    def setId(self, sid):
        """
        setId(Layout self, string sid) -> int


        Sets the value of the 'id' attribute of this Layout.

        The string 'sid' is copied.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Parameter 'sid' is the string to use as the identifier of this object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.Layout_setId(self, sid)


    def unsetId(self):
        """
        unsetId(Layout self) -> int


        Unsets the value of the 'id' attribute of this Layout.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.Layout_unsetId(self)


    def getName(self):
        """
        getName(Layout self) -> string


        Returns the value of the 'name' attribute of this Layout object.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns the name of this SBML object, or the empty string if not set
        or unsettable.

        See also getIdAttribute(), isSetName(), setName(), unsetName().

        """
        return _libsbml.Layout_getName(self)


    def isSetName(self):
        """
        isSetName(Layout self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        Layout's 'name' attribute has been set.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns 'True' if the 'name' attribute of this SBML object is set,
        'False' otherwise.

        See also getName(), setName(), unsetName().

        """
        return _libsbml.Layout_isSetName(self)


    def setName(self, name):
        """
        setName(Layout self, string name) -> int


        Sets the value of the 'name' attribute of this Layout.

        The string in 'name' is copied.

        Parameter 'name' is the new name for the SBML object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Layout_setName(self, name)


    def unsetName(self):
        """
        unsetName(Layout self) -> int


        Unsets the value of the 'name' attribute of this Layout.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getName(), setName(), isSetName().

        """
        return _libsbml.Layout_unsetName(self)


    def getDimensions(self):
        """
        getDimensions(Layout self) -> Dimensions


        Returns the dimensions of the layout.

        """
        return _libsbml.Layout_getDimensions(self)


    def setDimensions(self, dimensions):
        """
        setDimensions(Layout self, Dimensions dimensions)


        Sets the dimensions of the layout.

        """
        return _libsbml.Layout_setDimensions(self, dimensions)


    def getDimensionsExplicitlySet(self):
        """
        getDimensionsExplicitlySet(Layout self) -> bool


        Predicate returning true if the dimensions has been set

        """
        return _libsbml.Layout_getDimensionsExplicitlySet(self)


    def getListOfCompartmentGlyphs(self):
        """
        getListOfCompartmentGlyphs(Layout self) -> ListOfCompartmentGlyphs


        Returns the ListOf object that holds all compartment glyphs.

        """
        return _libsbml.Layout_getListOfCompartmentGlyphs(self)


    def getListOfSpeciesGlyphs(self):
        """
        getListOfSpeciesGlyphs(Layout self) -> ListOfSpeciesGlyphs


        Returns the ListOf object that holds all species glyphs.

        """
        return _libsbml.Layout_getListOfSpeciesGlyphs(self)


    def getListOfReactionGlyphs(self):
        """
        getListOfReactionGlyphs(Layout self) -> ListOfReactionGlyphs


        Returns the ListOf object that holds all reaction glyphs.

        """
        return _libsbml.Layout_getListOfReactionGlyphs(self)


    def getListOfTextGlyphs(self):
        """
        getListOfTextGlyphs(Layout self) -> ListOfTextGlyphs


        Returns the ListOf object that holds all text glyphs.

        """
        return _libsbml.Layout_getListOfTextGlyphs(self)


    def getListOfAdditionalGraphicalObjects(self):
        """
        getListOfAdditionalGraphicalObjects(Layout self) -> ListOfGraphicalObjects


        Returns the ListOf object that holds all additonal graphical objects.

        """
        return _libsbml.Layout_getListOfAdditionalGraphicalObjects(self)


    def getCompartmentGlyph(self, *args):
        """
        getCompartmentGlyph(Layout self, unsigned int index) -> CompartmentGlyph
        getCompartmentGlyph(Layout self, unsigned int index) -> CompartmentGlyph
        getCompartmentGlyph(Layout self, string id) -> CompartmentGlyph
        getCompartmentGlyph(Layout self, string id) -> CompartmentGlyph


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getCompartmentGlyph(long index)

        Returns the compartment glyph with the given index. If the index is
        invalid, 'None' is returned.

        ______________________________________________________________________
        Method variant with the following signature:

            getCompartmentGlyph(string id)

        Returns the compartment glyph that has the given 'id', or 'None' if no
        compartment glyph has the id.

        """
        return _libsbml.Layout_getCompartmentGlyph(self, *args)


    def getSpeciesGlyph(self, *args):
        """
        getSpeciesGlyph(Layout self, unsigned int index) -> SpeciesGlyph
        getSpeciesGlyph(Layout self, unsigned int index) -> SpeciesGlyph
        getSpeciesGlyph(Layout self, string id) -> SpeciesGlyph
        getSpeciesGlyph(Layout self, string id) -> SpeciesGlyph


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getSpeciesGlyph(long index)

        Returns the species glyph with the given index. If the index is
        invalid, 'None' is returned.

        ______________________________________________________________________
        Method variant with the following signature:

            getSpeciesGlyph(string id)

        Returns the species glyph that has the given 'id', or 'None' if no
        species glyph has the id.

        """
        return _libsbml.Layout_getSpeciesGlyph(self, *args)


    def getReactionGlyph(self, *args):
        """
        getReactionGlyph(Layout self, unsigned int index) -> ReactionGlyph
        getReactionGlyph(Layout self, unsigned int index) -> ReactionGlyph
        getReactionGlyph(Layout self, string id) -> ReactionGlyph
        getReactionGlyph(Layout self, string id) -> ReactionGlyph


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getReactionGlyph(long index)

        Returns the reaction glyph with the given index. If the index is
        invalid, 'None' is returned.

        ______________________________________________________________________
        Method variant with the following signature:

            getReactionGlyph(string id)

        Returns the reaction glyph that has the given 'id', or 'None' if no
        reaction glyph has the id.

        """
        return _libsbml.Layout_getReactionGlyph(self, *args)


    def getTextGlyph(self, *args):
        """
        getTextGlyph(Layout self, unsigned int index) -> TextGlyph
        getTextGlyph(Layout self, unsigned int index) -> TextGlyph
        getTextGlyph(Layout self, string id) -> TextGlyph
        getTextGlyph(Layout self, string id) -> TextGlyph


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getTextGlyph(long index)

        Returns the text glyph with the given index. If the index is invalid,
        'None' is returned.

        ______________________________________________________________________
        Method variant with the following signature:

            getTextGlyph(string id)

        Returns the text glyph that has the given 'id', or 'None' if no text
        glyph has the id.

        """
        return _libsbml.Layout_getTextGlyph(self, *args)


    def getAdditionalGraphicalObject(self, *args):
        """
        getAdditionalGraphicalObject(Layout self, unsigned int index) -> GraphicalObject
        getAdditionalGraphicalObject(Layout self, unsigned int index) -> GraphicalObject
        getAdditionalGraphicalObject(Layout self, string id) -> GraphicalObject
        getAdditionalGraphicalObject(Layout self, string id) -> GraphicalObject


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getAdditionalGraphicalObject(long index)

        Returns the additional graphical object with the given index. If the
        index is invalid, 'None' is returned.

        ______________________________________________________________________
        Method variant with the following signature:

            getAdditionalGraphicalObject(string id)

        Returns the additional graphical object that has the given 'id', or
        'None' if no graphical object has the id.

        """
        return _libsbml.Layout_getAdditionalGraphicalObject(self, *args)


    def getGeneralGlyph(self, *args):
        """
        getGeneralGlyph(Layout self, unsigned int index) -> GeneralGlyph
        getGeneralGlyph(Layout self, unsigned int index) -> GeneralGlyph
        getGeneralGlyph(Layout self, string id) -> GeneralGlyph
        getGeneralGlyph(Layout self, string id) -> GeneralGlyph


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getGeneralGlyph(long index)

        Returns the general glyph with the given index. If the index is
        invalid, 'None' is returned.

        ______________________________________________________________________
        Method variant with the following signature:

            getGeneralGlyph(string id)

        Returns the general glyph that has the given 'id', or 'None' if no
        graphical object has the id.

        """
        return _libsbml.Layout_getGeneralGlyph(self, *args)


    def addCompartmentGlyph(self, glyph):
        """
        addCompartmentGlyph(Layout self, CompartmentGlyph glyph) -> int


        Adds a new compartment glyph.

        """
        return _libsbml.Layout_addCompartmentGlyph(self, glyph)


    def addSpeciesGlyph(self, glyph):
        """
        addSpeciesGlyph(Layout self, SpeciesGlyph glyph) -> int


        Adds a new species glyph.

        """
        return _libsbml.Layout_addSpeciesGlyph(self, glyph)


    def addReactionGlyph(self, glyph):
        """
        addReactionGlyph(Layout self, ReactionGlyph glyph) -> int


        Adds a new reaction glyph.

        """
        return _libsbml.Layout_addReactionGlyph(self, glyph)


    def addTextGlyph(self, glyph):
        """
        addTextGlyph(Layout self, TextGlyph glyph) -> int


        Adds a new text glyph.

        """
        return _libsbml.Layout_addTextGlyph(self, glyph)


    def addAdditionalGraphicalObject(self, glyph):
        """
        addAdditionalGraphicalObject(Layout self, GraphicalObject glyph) -> int


        Adds a new additional graphical object glyph.

        """
        return _libsbml.Layout_addAdditionalGraphicalObject(self, glyph)


    def addGeneralGlyph(self, glyph):
        """
        addGeneralGlyph(Layout self, GeneralGlyph glyph) -> int


        Adds a new general glyph.

        """
        return _libsbml.Layout_addGeneralGlyph(self, glyph)


    def getNumCompartmentGlyphs(self):
        """
        getNumCompartmentGlyphs(Layout self) -> unsigned int


        Returns the number of compartment glyphs for the layout.

        """
        return _libsbml.Layout_getNumCompartmentGlyphs(self)


    def getNumSpeciesGlyphs(self):
        """
        getNumSpeciesGlyphs(Layout self) -> unsigned int


        Returns the number of species glyphs for the layout.

        """
        return _libsbml.Layout_getNumSpeciesGlyphs(self)


    def getNumReactionGlyphs(self):
        """
        getNumReactionGlyphs(Layout self) -> unsigned int


        Returns the number of reaction glyphs for the layout.

        """
        return _libsbml.Layout_getNumReactionGlyphs(self)


    def getNumTextGlyphs(self):
        """
        getNumTextGlyphs(Layout self) -> unsigned int


        Returns the number of text glyphs for the layout.

        """
        return _libsbml.Layout_getNumTextGlyphs(self)


    def getNumAdditionalGraphicalObjects(self):
        """
        getNumAdditionalGraphicalObjects(Layout self) -> unsigned int


        Returns the number of additional graphical objects for the layout.

        """
        return _libsbml.Layout_getNumAdditionalGraphicalObjects(self)


    def getNumGeneralGlyphs(self):
        """
        getNumGeneralGlyphs(Layout self) -> unsigned int


        Returns the number of general glyphs for the layout.

        """
        return _libsbml.Layout_getNumGeneralGlyphs(self)


    def createCompartmentGlyph(self):
        """
        createCompartmentGlyph(Layout self) -> CompartmentGlyph


        Creates a CompartmentGlyph object, adds it to the end of the
        compartment glyph objects list and returns a pointer to the newly
        created object.

        """
        return _libsbml.Layout_createCompartmentGlyph(self)


    def createSpeciesGlyph(self):
        """
        createSpeciesGlyph(Layout self) -> SpeciesGlyph


        Creates a SpeciesGlyph object, adds it to the end of the species glyph
        objects list and returns a pointer to the newly created object.

        """
        return _libsbml.Layout_createSpeciesGlyph(self)


    def createReactionGlyph(self):
        """
        createReactionGlyph(Layout self) -> ReactionGlyph


        Creates a ReactionGlyph object, adds it to the end of the reaction
        glyph objects list and returns a pointer to the newly created object.

        """
        return _libsbml.Layout_createReactionGlyph(self)


    def createGeneralGlyph(self):
        """
        createGeneralGlyph(Layout self) -> GeneralGlyph


        Creates a GeneralGlyph object, adds it to the end of the additional
        objects list and returns a reference to the newly created object.

        """
        return _libsbml.Layout_createGeneralGlyph(self)


    def createTextGlyph(self):
        """
        createTextGlyph(Layout self) -> TextGlyph


        Creates a TextGlyph object, adds it to the end of the text glyph
        objects list and returns a pointer to the newly created object.

        """
        return _libsbml.Layout_createTextGlyph(self)


    def createAdditionalGraphicalObject(self):
        """
        createAdditionalGraphicalObject(Layout self) -> GraphicalObject


        Creates a GraphicalObject object, adds it to the end of the additional
        graphical objects list and returns a pointer to the newly created
        object.

        """
        return _libsbml.Layout_createAdditionalGraphicalObject(self)


    def createSpeciesReferenceGlyph(self):
        """
        createSpeciesReferenceGlyph(Layout self) -> SpeciesReferenceGlyph


        Creates a new SpeciesReferenceGlyph for the last ReactionGlyph and
        adds it to its list of SpeciesReferenceGlyph objects.  A pointer to
        the newly created object is returned.

        """
        return _libsbml.Layout_createSpeciesReferenceGlyph(self)


    def createLineSegment(self):
        """
        createLineSegment(Layout self) -> LineSegment


        Creates a new LineSegment for the Curve object of the last
        ReactionGlyph or the last SpeciesReferenceGlyph in the last
        ReactionGlyph and adds it to its list of SpeciesReferenceGlyph
        objects.  A pointer to the newly created object is returned.

        """
        return _libsbml.Layout_createLineSegment(self)


    def createCubicBezier(self):
        """
        createCubicBezier(Layout self) -> CubicBezier


        Creates a new CubicBezier for the Curve object of the last
        ReactionGlyph or the last SpeciesReferenceGlyph in the last
        ReactionGlyph and adds it to its list of SpeciesReferenceGlyph
        objects.  A pointer to the newly created object is returned.

        """
        return _libsbml.Layout_createCubicBezier(self)


    def removeCompartmentGlyph(self, *args):
        """
        removeCompartmentGlyph(Layout self, unsigned int index) -> CompartmentGlyph
        removeCompartmentGlyph(Layout self, string id) -> CompartmentGlyph


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeCompartmentGlyph(long index)

        Removes the compartment glyph with the given index from the layout. A
        pointer to the compartment glyph that was removed is returned. If no
        compartment glyph has been removed, 'None' is returned.

        ______________________________________________________________________
        Method variant with the following signature:

            removeCompartmentGlyph(string id)

        Remove the compartment glyph with the given 'id'. A pointer to the
        removed compartment glyph is returned. If no compartment glyph has
        been removed, 'None' is returned.

        """
        return _libsbml.Layout_removeCompartmentGlyph(self, *args)


    def removeSpeciesGlyph(self, *args):
        """
        removeSpeciesGlyph(Layout self, unsigned int index) -> SpeciesGlyph
        removeSpeciesGlyph(Layout self, string id) -> SpeciesGlyph


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeSpeciesGlyph(long index)

        Removes the species glyph with the given index from the layout. A
        pointer to the species glyph that was removed is returned. If no
        species glyph has been removed, 'None' is returned.

        ______________________________________________________________________
        Method variant with the following signature:

            removeSpeciesGlyph(string id)

        Remove the species glyph with the given 'id'. A pointer to the removed
        species glyph is returned. If no species glyph has been removed,
        'None' is returned.

        """
        return _libsbml.Layout_removeSpeciesGlyph(self, *args)


    def removeReactionGlyph(self, *args):
        """
        removeReactionGlyph(Layout self, unsigned int index) -> ReactionGlyph
        removeReactionGlyph(Layout self, string id) -> ReactionGlyph


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeReactionGlyph(long index)

        Removes the reaction glyph with the given index from the layout. A
        pointer to the reaction glyph that was removed is returned. If no
        reaction glyph has been removed, 'None' is returned.

        ______________________________________________________________________
        Method variant with the following signature:

            removeReactionGlyph(string id)

        Remove the reaction glyph with the given 'id'. A pointer to the
        removed reaction glyph is returned. If no reaction glyph has been
        removed, 'None' is returned.

        """
        return _libsbml.Layout_removeReactionGlyph(self, *args)


    def removeSpeciesReferenceGlyph(self, id):
        """
        removeSpeciesReferenceGlyph(Layout self, string id) -> SpeciesReferenceGlyph


        Remove the species reference glyph with the given 'id'. A pointer to
        the removed species reference glyph is returned. If no species
        reference glyph has been removed, 'None' is returned.

        """
        return _libsbml.Layout_removeSpeciesReferenceGlyph(self, id)


    def removeTextGlyph(self, *args):
        """
        removeTextGlyph(Layout self, unsigned int index) -> TextGlyph
        removeTextGlyph(Layout self, string id) -> TextGlyph


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeTextGlyph(long index)

        Removes the text glyph with the given index from the layout. A pointer
        to the text glyph that was removed is returned. If no text glyph has
        been removed, 'None' is returned.

        ______________________________________________________________________
        Method variant with the following signature:

            removeTextGlyph(string id)

        Remove the text glyph with the given 'id'. A pointer to the removed
        text glyph is returned. If no text glyph has been removed, 'None' is
        returned.

        """
        return _libsbml.Layout_removeTextGlyph(self, *args)


    def removeAdditionalGraphicalObject(self, *args):
        """
        removeAdditionalGraphicalObject(Layout self, unsigned int index) -> GraphicalObject
        removeAdditionalGraphicalObject(Layout self, string id) -> GraphicalObject


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeAdditionalGraphicalObject(long index)

        Removes the graphical object with the given index from the layout. A
        pointer to the graphical object that was removed is returned. If no
        graphical object has been removed, 'None' is returned.

        ______________________________________________________________________
        Method variant with the following signature:

            removeAdditionalGraphicalObject(string id)

        Remove the graphical object with the given 'id'. A pointer to the
        removed graphical object is returned. If no graphical object has been
        removed, 'None' is returned.

        """
        return _libsbml.Layout_removeAdditionalGraphicalObject(self, *args)


    def getElementName(self):
        """
        getElementName(Layout self) -> string


        Returns the XML element name of this SBML object.

        Returns the string of the name of this element.

        """
        return _libsbml.Layout_getElementName(self)


    def clone(self):
        """
        clone(Layout self) -> Layout


        Creates and returns a deep copy of this Layout.

        Returns a (deep) copy of this Layout.

        """
        return _libsbml.Layout_clone(self)


    def getTypeCode(self):
        """
        getTypeCode(Layout self) -> int


        Returns the libSBML type code of this object instance.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_LAYOUT_LAYOUT.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.Layout_getTypeCode(self)


    def toXML(self):
        """
        toXML(Layout self) -> XMLNode


        Creates an XMLNode object from this.

        """
        return _libsbml.Layout_toXML(self)


    def connectToChild(self):
        """connectToChild(Layout self)"""
        return _libsbml.Layout_connectToChild(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(Layout self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.Layout_enablePackageInternal(self, pkgURI, pkgPrefix, flag)

Layout_swigregister = _libsbml.Layout_swigregister
Layout_swigregister(Layout)

class ListOfLayouts(ListOf):
    """

    [SBML 'layout' package]

    A list of Layout objects.

    The ListOfLayouts is a container for the Layout elements of an
    extended Model element.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    See also Layout.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfLayouts, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfLayouts, name)
    __repr__ = _swig_repr

    def clone(self):
        """
        clone(ListOfLayouts self) -> ListOfLayouts


        Creates and returns a deep copy of this ListOfLayouts.

        Returns a (deep) copy of this ListOfLayouts.

        """
        return _libsbml.ListOfLayouts_clone(self)


    def __init__(self, *args):
        """
        __init__(ListOfLayouts self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ListOfLayouts
        __init__(ListOfLayouts self, unsigned int level, unsigned int version) -> ListOfLayouts
        __init__(ListOfLayouts self, unsigned int level) -> ListOfLayouts
        __init__(ListOfLayouts self) -> ListOfLayouts
        __init__(ListOfLayouts self, LayoutPkgNamespaces layoutns) -> ListOfLayouts


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfLayouts(LayoutPkgNamespaces layoutns)

        Constructor.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'layoutns' is the LayoutPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfLayouts(long level      =
        LayoutExtension.getDefaultLevel(), long version    =
        LayoutExtension.getDefaultVersion(), long pkgVersion =
        LayoutExtension.getDefaultPackageVersion())

        Constructor.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        this = _libsbml.new_ListOfLayouts(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfLayouts self) -> int


        Returns the libSBML type code for the SBML objects contained in this
        ListOf object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for objects contained in this list:
        SBML_LAYOUT_LAYOUT (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfLayouts_getItemTypeCode(self)


    def getElementName(self):
        """
        getElementName(ListOfLayouts self) -> string


        Returns the XML element name of this SBML object.

        Returns the string of the name of this element.

        """
        return _libsbml.ListOfLayouts_getElementName(self)


    def get(self, *args):
        """
        get(ListOfLayouts self, unsigned int n) -> Layout
        get(ListOfLayouts self, unsigned int n) -> Layout
        get(ListOfLayouts self, string sid) -> Layout
        get(ListOfLayouts self, string sid) -> Layout


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a Layout from the ListOfLayouts.

        Parameter 'n' is the index number of the Layout to get.

        Returns the nth Layout in this ListOfLayouts. If the index 'n' is
        invalid, 'None' is returned.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a Layout from the ListOfLayouts based on its identifier.

        Parameter 'sid' is a string representing the identifier  of the Layout
        to get.

        Returns Layout in this ListOfLayouts with the given 'sid' or 'None' if
        no such Layout exists.

        See also get(), size().

        """
        return _libsbml.ListOfLayouts_get(self, *args)


    def remove(self, *args):
        """
        remove(ListOfLayouts self, unsigned int n) -> Layout
        remove(ListOfLayouts self, string sid) -> Layout


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth item from this ListOfLayouts items and returns a
        pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the item to remove.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes item in this ListOfLayouts 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 'sid', then
        'None' is returned.

        Parameter 'sid' is the identifier of the item to remove.

        Returns the item removed.  As mentioned above, the caller owns the
        returned item.

        """
        return _libsbml.ListOfLayouts_remove(self, *args)


    def toXML(self):
        """
        toXML(ListOfLayouts self) -> XMLNode


        Creates an XMLNode object from this.

        """
        return _libsbml.ListOfLayouts_toXML(self)


    def resetElementNamespace(self, uri):
        """
        resetElementNamespace(ListOfLayouts self, string uri)




        """
        return _libsbml.ListOfLayouts_resetElementNamespace(self, uri)

    __swig_destroy__ = _libsbml.delete_ListOfLayouts
    __del__ = lambda self: None
ListOfLayouts_swigregister = _libsbml.ListOfLayouts_swigregister
ListOfLayouts_swigregister(ListOfLayouts)

class LayoutExtension(SBMLExtension):
    """

    [SBML 'layout' package]

    Base extension class for the package.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    """

    __swig_setmethods__ = {}
    for _s in [SBMLExtension]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LayoutExtension, name, value)
    __swig_getmethods__ = {}
    for _s in [SBMLExtension]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, LayoutExtension, name)
    __repr__ = _swig_repr

    def getPackageName():
        """
        getPackageName() -> string


        Returns the nickname of the SBML Level 3 package implemented by this
        libSBML extension.

        Returns the package nickname, as a string.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.LayoutExtension_getPackageName()

    getPackageName = staticmethod(getPackageName)

    def getDefaultLevel():
        """
        getDefaultLevel() -> unsigned int


        Returns the default SBML Level used by this libSBML package extension.

        Returns the SBML Level.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.LayoutExtension_getDefaultLevel()

    getDefaultLevel = staticmethod(getDefaultLevel)

    def getDefaultVersion():
        """
        getDefaultVersion() -> unsigned int


        Returns the default SBML Version used by this libSBML package
        extension.

        Returns the Version within the default SBML Level.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.LayoutExtension_getDefaultVersion()

    getDefaultVersion = staticmethod(getDefaultVersion)

    def getDefaultPackageVersion():
        """
        getDefaultPackageVersion() -> unsigned int


        Returns the default version of the SBML Level 3 package implemented by
        this libSBML extension.

        Returns the default version number of the SBML Level 3 package
        definition.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.LayoutExtension_getDefaultPackageVersion()

    getDefaultPackageVersion = staticmethod(getDefaultPackageVersion)

    def getXmlnsL3V1V1():
        """
        getXmlnsL3V1V1() -> string


        Returns the XML namespace URI of the SBML Level 3 package implemented
        by this libSBML extension.

        Returns the XML namespace as a string.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.LayoutExtension_getXmlnsL3V1V1()

    getXmlnsL3V1V1 = staticmethod(getXmlnsL3V1V1)

    def getXmlnsL2():
        """
        getXmlnsL2() -> string


        Returns the XML namespace URI of the SBML Level 2 version of the
        package implemented by this libSBML Extension.

        Unique among the SBML Level 3 packages, the Layout package existed and
        was in widespread use prior to the introduction of SBML Level 3.  The
        Layout package was used as model annotations in SBML Level 2.  This
        method returns the SBML annotation XML namespace used for Level 2.

        Returns the XML namespace as a string.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.LayoutExtension_getXmlnsL2()

    getXmlnsL2 = staticmethod(getXmlnsL2)

    def getXmlnsXSI():
        """
        getXmlnsXSI() -> string


        Returns the XML namespace URI of any additional XML namespaces needed
        or used by this SBML Level 3 package.

        Returns the XML namespace as a string.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.LayoutExtension_getXmlnsXSI()

    getXmlnsXSI = staticmethod(getXmlnsXSI)

    def __init__(self, *args):
        """
        __init__(LayoutExtension self) -> LayoutExtension
        __init__(LayoutExtension self, LayoutExtension orig) -> LayoutExtension


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            LayoutExtension(LayoutExtension orig)

        Copy constructor.

        Parameter 'orig' is the instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            LayoutExtension()

        Creates a new LayoutExtension instance.

        """
        this = _libsbml.new_LayoutExtension(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_LayoutExtension
    __del__ = lambda self: None

    def clone(self):
        """
        clone(LayoutExtension self) -> LayoutExtension


        Creates and returns a deep copy of this LayoutExtension object.

        Returns a (deep) copy of this LayoutExtension object.

        """
        return _libsbml.LayoutExtension_clone(self)


    def getName(self):
        """
        getName(LayoutExtension self) -> string


        Returns the name of this package ('layout')

        Returns the name of this package ('layout').

        """
        return _libsbml.LayoutExtension_getName(self)


    def getURI(self, sbmlLevel, sbmlVersion, pkgVersion):
        """
        getURI(LayoutExtension self, unsigned int sbmlLevel, unsigned int sbmlVersion, unsigned int pkgVersion) -> string


        Returns a string representing the SBML XML namespace of this SBML
        Level 3 package.

        The namespace URI constructed by this method corresponds to the
        combination of the Level and Version of SBML, and the Version of the
        SBML Level 3 package. (At the time of this writing, the only SBML
        Level that supports packages is Level 3, so the value of 'sbmlLevel'
        must necessarily always be 3.)

        Parameter 'sbmlLevel' is the level of SBML. Parameter 'sbmlVersion' is
        the version of SBML. Parameter 'pkgVersion' is the version of the
        package.

        Returns a string of the package URI, or an empty string if no
        corresponding URI exists.

        """
        return _libsbml.LayoutExtension_getURI(self, sbmlLevel, sbmlVersion, pkgVersion)


    def getLevel(self, uri):
        """
        getLevel(LayoutExtension self, string uri) -> unsigned int


        Returns the SBML Level for the given URI of this package.

        Parameter 'uri' is a URI that represents a version of this package.

        Returns the SBML Level for the given URI of this package, or '0' if
        the given URI is invalid, or for a different package.

        """
        return _libsbml.LayoutExtension_getLevel(self, uri)


    def getVersion(self, uri):
        """
        getVersion(LayoutExtension self, string uri) -> unsigned int


        Returns the Version within the SBML Level for the given URI of this
        package.

        Parameter 'uri' is a URI that represents a version of this package.

        Returns the SBML Version within the SBML Level for the given URI of
        this package, or '0' if the given URI is invalid, or for a different
        package.

        """
        return _libsbml.LayoutExtension_getVersion(self, uri)


    def getPackageVersion(self, uri):
        """
        getPackageVersion(LayoutExtension self, string uri) -> unsigned int


        Returns the SBML Level 3 package version for the given URI of this
        package.

        Parameter 'uri' is a URI that represents one of the valid versions of
        this package.

        Returns the version of the SBML Level 3 package with the given URI, or
        '0' if the given URI is invalid, or for a different package.

        """
        return _libsbml.LayoutExtension_getPackageVersion(self, uri)


    def getStringFromTypeCode(self, typeCode):
        """
        getStringFromTypeCode(LayoutExtension self, int typeCode) -> char const *


        Takes a type code of the "layout" package and returns a string
        describing the code.

        Parameter 'typeCode' is a libSBML type code defined by the libSBML
        extension. implementing support for the SBML Level 3 "layout"
        package.

        Returns a text string representing the type code given by 'typeCode'.
        If the type code is unrecognized for this implementation of the
        libSBML "layout" package, the string returned will be '(Unknown SBML
        Layout Type)'.

        """
        return _libsbml.LayoutExtension_getStringFromTypeCode(self, typeCode)


    def getSBMLExtensionNamespaces(self, uri):
        """
        getSBMLExtensionNamespaces(LayoutExtension self, string uri) -> SBMLNamespaces


        Returns a LayoutPkgNamespaces object.

        Parameter 'uri' is a URI that represents one of the valid versions of
        the "layout" package.

        Returns a LayoutPkgNamespaces object corresponding to the given 'uri',
        or 'None' if the URI is not defined in the Layout package.

        """
        return _libsbml.LayoutExtension_getSBMLExtensionNamespaces(self, uri)


    def init():
        """
        init()


        Internal implementation method.

        """
        return _libsbml.LayoutExtension_init()

    init = staticmethod(init)

    def removeL2Namespaces(self, xmlns):
        """
        removeL2Namespaces(LayoutExtension self, XMLNamespaces xmlns)


        Removes the L2 Namespace from a document.

        This method is overridden here since Layout does serialize to an L2
        annotation.

        """
        return _libsbml.LayoutExtension_removeL2Namespaces(self, xmlns)


    def addL2Namespaces(self, xmlns):
        """
        addL2Namespaces(LayoutExtension self, XMLNamespaces xmlns)


        adds all L2 Extension namespaces to the namespace list.

        This method is overridden here since Layout does serialize to an L2
        annotation.

        """
        return _libsbml.LayoutExtension_addL2Namespaces(self, xmlns)


    def enableL2NamespaceForDocument(self, doc):
        """
        enableL2NamespaceForDocument(LayoutExtension self, SBMLDocument doc)


        Adds the L2 Namespace to the document and enables the extension.

        This method is overridden here since Layout does serialize to an L2
        annotation.

        """
        return _libsbml.LayoutExtension_enableL2NamespaceForDocument(self, doc)


    def isInUse(self, doc):
        """
        isInUse(LayoutExtension self, SBMLDocument doc) -> bool


        Determines whether this extension is being used by the given
        SBMLDocument

        The implementation returns true if the model object contains one  or
        more layouts.

        Parameter 'doc' is the sbml document to test.

        Returns a boolean indicating whether the extension is actually being
        used by the document.

        """
        return _libsbml.LayoutExtension_isInUse(self, doc)


    def getErrorTable(self, index):
        """
        getErrorTable(LayoutExtension self, unsigned int index) -> packageErrorTableEntry


        Internal implementation method.

        """
        return _libsbml.LayoutExtension_getErrorTable(self, index)


    def getErrorTableIndex(self, errorId):
        """
        getErrorTableIndex(LayoutExtension self, unsigned int errorId) -> unsigned int


        Internal implementation method.

        """
        return _libsbml.LayoutExtension_getErrorTableIndex(self, errorId)


    def getErrorIdOffset(self):
        """
        getErrorIdOffset(LayoutExtension self) -> unsigned int


        Internal implementation method.

        """
        return _libsbml.LayoutExtension_getErrorIdOffset(self)

LayoutExtension_swigregister = _libsbml.LayoutExtension_swigregister
LayoutExtension_swigregister(LayoutExtension)

def LayoutExtension_getPackageName():
    """
    LayoutExtension_getPackageName() -> string


    Returns the nickname of the SBML Level 3 package implemented by this
    libSBML extension.

    Returns the package nickname, as a string.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.LayoutExtension_getPackageName()

def LayoutExtension_getDefaultLevel():
    """
    LayoutExtension_getDefaultLevel() -> unsigned int


    Returns the default SBML Level used by this libSBML package extension.

    Returns the SBML Level.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.LayoutExtension_getDefaultLevel()

def LayoutExtension_getDefaultVersion():
    """
    LayoutExtension_getDefaultVersion() -> unsigned int


    Returns the default SBML Version used by this libSBML package
    extension.

    Returns the Version within the default SBML Level.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.LayoutExtension_getDefaultVersion()

def LayoutExtension_getDefaultPackageVersion():
    """
    LayoutExtension_getDefaultPackageVersion() -> unsigned int


    Returns the default version of the SBML Level 3 package implemented by
    this libSBML extension.

    Returns the default version number of the SBML Level 3 package
    definition.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.LayoutExtension_getDefaultPackageVersion()

def LayoutExtension_getXmlnsL3V1V1():
    """
    LayoutExtension_getXmlnsL3V1V1() -> string


    Returns the XML namespace URI of the SBML Level 3 package implemented
    by this libSBML extension.

    Returns the XML namespace as a string.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.LayoutExtension_getXmlnsL3V1V1()

def LayoutExtension_getXmlnsL2():
    """
    LayoutExtension_getXmlnsL2() -> string


    Returns the XML namespace URI of the SBML Level 2 version of the
    package implemented by this libSBML Extension.

    Unique among the SBML Level 3 packages, the Layout package existed and
    was in widespread use prior to the introduction of SBML Level 3.  The
    Layout package was used as model annotations in SBML Level 2.  This
    method returns the SBML annotation XML namespace used for Level 2.

    Returns the XML namespace as a string.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.LayoutExtension_getXmlnsL2()

def LayoutExtension_getXmlnsXSI():
    """
    LayoutExtension_getXmlnsXSI() -> string


    Returns the XML namespace URI of any additional XML namespaces needed
    or used by this SBML Level 3 package.

    Returns the XML namespace as a string.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.LayoutExtension_getXmlnsXSI()

def LayoutExtension_init():
    """
    LayoutExtension_init()


    Internal implementation method.

    """
    return _libsbml.LayoutExtension_init()

SBML_LAYOUT_BOUNDINGBOX = _libsbml.SBML_LAYOUT_BOUNDINGBOX
SBML_LAYOUT_COMPARTMENTGLYPH = _libsbml.SBML_LAYOUT_COMPARTMENTGLYPH
SBML_LAYOUT_CUBICBEZIER = _libsbml.SBML_LAYOUT_CUBICBEZIER
SBML_LAYOUT_CURVE = _libsbml.SBML_LAYOUT_CURVE
SBML_LAYOUT_DIMENSIONS = _libsbml.SBML_LAYOUT_DIMENSIONS
SBML_LAYOUT_GRAPHICALOBJECT = _libsbml.SBML_LAYOUT_GRAPHICALOBJECT
SBML_LAYOUT_LAYOUT = _libsbml.SBML_LAYOUT_LAYOUT
SBML_LAYOUT_LINESEGMENT = _libsbml.SBML_LAYOUT_LINESEGMENT
SBML_LAYOUT_POINT = _libsbml.SBML_LAYOUT_POINT
SBML_LAYOUT_REACTIONGLYPH = _libsbml.SBML_LAYOUT_REACTIONGLYPH
SBML_LAYOUT_SPECIESGLYPH = _libsbml.SBML_LAYOUT_SPECIESGLYPH
SBML_LAYOUT_SPECIESREFERENCEGLYPH = _libsbml.SBML_LAYOUT_SPECIESREFERENCEGLYPH
SBML_LAYOUT_TEXTGLYPH = _libsbml.SBML_LAYOUT_TEXTGLYPH
SBML_LAYOUT_REFERENCEGLYPH = _libsbml.SBML_LAYOUT_REFERENCEGLYPH
SBML_LAYOUT_GENERALGLYPH = _libsbml.SBML_LAYOUT_GENERALGLYPH
class LayoutModelPlugin(SBasePlugin):
    """

    [SBML 'layout' package]

    Extension of Model.

    """

    __swig_setmethods__ = {}
    for _s in [SBasePlugin]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LayoutModelPlugin, name, value)
    __swig_getmethods__ = {}
    for _s in [SBasePlugin]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, LayoutModelPlugin, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(LayoutModelPlugin self, string uri, string prefix, LayoutPkgNamespaces layoutns) -> LayoutModelPlugin
        __init__(LayoutModelPlugin self, LayoutModelPlugin orig) -> LayoutModelPlugin


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            LayoutModelPlugin(LayoutModelPlugin orig)

        Copy constructor. Creates a copy of this SBase object.

        Parameter 'orig' is the instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            LayoutModelPlugin(string &uri, string &prefix,
        LayoutPkgNamespaces layoutns)

        Creates a new LayoutModelPlugin object using the given parameters.

        In the XML representation of an SBML document, XML namespaces are
        used to identify the origin of each XML construct used.  XML
        namespaces are identified by their unique resource identifiers (URIs).
        The core SBML specifications stipulate the namespaces that must be
        used for core SBML constructs; for example, all XML elements that
        belong to SBML Level 3 Version 1 Core must be placed in the XML
        namespace identified by the URI
        'http://www.sbml.org/sbml/level3/version1/core'.  Individual SBML
        Level 3 packages define their own XML namespaces; for example, all
        elements belonging to the SBML Level 3 Layout Version 1 package must
        be placed in the XML namespace
        'http://www.sbml.org/sbml/level3/version1/layout/version1/'.

        The SBMLNamespaces object encapsulates SBML Level/Version/namespaces
        information.  It is used to communicate the SBML Level, Version, and
        (in Level 3) packages used in addition to SBML Level 3 Core.  A common
        approach to using libSBML's SBMLNamespaces facilities is to create an
        SBMLNamespaces object somewhere in a program once, then hand that
        object as needed to object constructors that accept SBMLNamespaces as
        arguments.

        Parameter 'uri' is the URI of the SBML Level 3 package implemented by
        this libSBML package extension.

        Parameter 'prefix' is the XML namespace prefix being used for the
        package.

        Parameter 'layoutns' is the namespaces object for the package.

        """
        this = _libsbml.new_LayoutModelPlugin(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_LayoutModelPlugin
    __del__ = lambda self: None

    def clone(self):
        """
        clone(LayoutModelPlugin self) -> LayoutModelPlugin


        Creates and returns a deep copy of this LayoutModelPlugin object.

        Returns a (deep) copy of this LayoutModelPlugin object.

        """
        return _libsbml.LayoutModelPlugin_clone(self)


    def getListOfLayouts(self, *args):
        """
        getListOfLayouts(LayoutModelPlugin self) -> ListOfLayouts
        getListOfLayouts(LayoutModelPlugin self) -> ListOfLayouts


        Returns the ListOfLayouts object for this Model.

        Returns the ListOfLayouts object for this Model.

        """
        return _libsbml.LayoutModelPlugin_getListOfLayouts(self, *args)


    def getLayout(self, *args):
        """
        getLayout(LayoutModelPlugin self, unsigned int index) -> Layout
        getLayout(LayoutModelPlugin self, unsigned int index) -> Layout
        getLayout(LayoutModelPlugin self, string sid) -> Layout
        getLayout(LayoutModelPlugin self, string sid) -> Layout


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getLayout(long index)

        Returns the layout object that belongs to the given index. If the
        index is invalid, 'None' is returned.

        Parameter 'index' is the index of list of layout objects.

        Returns the Layout object that belongs to the given index. None is
        returned if the index is invalid.

        ______________________________________________________________________
        Method variant with the following signature:

            getLayout(string sid)

        Returns the layout object with the given 'sid' attribute. If the id is
        invalid, 'None' is returned.

        Parameter 'sid' is the id attribute of the layout object.

        Returns the Layout object with the given 'sid' attribute. None is
        returned if the given 'sid' is invalid.

        """
        return _libsbml.LayoutModelPlugin_getLayout(self, *args)


    def addLayout(self, layout):
        """
        addLayout(LayoutModelPlugin self, Layout layout) -> int


        Adds a copy of the layout object to the list of layouts.

        Parameter 'layout' is the layout object to be added.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_PKG_VERSION_MISMATCH

        * LIBSBML_DUPLICATE_OBJECT_ID

        """
        return _libsbml.LayoutModelPlugin_addLayout(self, layout)


    def createLayout(self):
        """
        createLayout(LayoutModelPlugin self) -> Layout


        Creates a new layout object and adds it to the list of layout objects
        and returns it.

        Returns a new layout object.

        """
        return _libsbml.LayoutModelPlugin_createLayout(self)


    def removeLayout(self, n):
        """
        removeLayout(LayoutModelPlugin self, unsigned int n) -> Layout


        Removes the nth Layout object from this Model object and returns a
        pointer to it.

        The caller owns the returned object and is responsible for deleting
        it.

        Parameter 'n' is the index of the Layout object to remove.

        Returns the Layout object removed.  As mentioned above, the caller
        owns the returned object. 'None' is returned if the given index is out
        of range.

        """
        return _libsbml.LayoutModelPlugin_removeLayout(self, n)


    def getNumLayouts(self):
        """
        getNumLayouts(LayoutModelPlugin self) -> int


        Returns the number of layout objects.

        Returns the number of layout objects.

        """
        return _libsbml.LayoutModelPlugin_getNumLayouts(self)


    def appendFrom(self, model):
        """
        appendFrom(LayoutModelPlugin self, Model model) -> int


        Internal implementation method.

        """
        return _libsbml.LayoutModelPlugin_appendFrom(self, model)


    def connectToParent(self, sbase):
        """
        connectToParent(LayoutModelPlugin self, SBase sbase)


        Internal implementation method.

        """
        return _libsbml.LayoutModelPlugin_connectToParent(self, sbase)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(LayoutModelPlugin self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.LayoutModelPlugin_enablePackageInternal(self, pkgURI, pkgPrefix, flag)

LayoutModelPlugin_swigregister = _libsbml.LayoutModelPlugin_swigregister
LayoutModelPlugin_swigregister(LayoutModelPlugin)

class LayoutSpeciesReferencePlugin(SBasePlugin):
    """

    [SBML 'layout' package]

    Extension of SpeciesReference.

    """

    __swig_setmethods__ = {}
    for _s in [SBasePlugin]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LayoutSpeciesReferencePlugin, name, value)
    __swig_getmethods__ = {}
    for _s in [SBasePlugin]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, LayoutSpeciesReferencePlugin, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(LayoutSpeciesReferencePlugin self, string uri, string prefix, LayoutPkgNamespaces layoutns) -> LayoutSpeciesReferencePlugin
        __init__(LayoutSpeciesReferencePlugin self, LayoutSpeciesReferencePlugin orig) -> LayoutSpeciesReferencePlugin


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            LayoutSpeciesReferencePlugin(string &uri, string &prefix,
        LayoutPkgNamespaces layoutns)

        Creates a new LayoutSpeciesReferencePlugin object using the given
        parameters.

        In the XML representation of an SBML document, XML namespaces are
        used to identify the origin of each XML construct used.  XML
        namespaces are identified by their unique resource identifiers (URIs).
        The core SBML specifications stipulate the namespaces that must be
        used for core SBML constructs; for example, all XML elements that
        belong to SBML Level 3 Version 1 Core must be placed in the XML
        namespace identified by the URI
        'http://www.sbml.org/sbml/level3/version1/core'.  Individual SBML
        Level 3 packages define their own XML namespaces; for example, all
        elements belonging to the SBML Level 3 Layout Version 1 package must
        be placed in the XML namespace
        'http://www.sbml.org/sbml/level3/version1/layout/version1/'.

        The SBMLNamespaces object encapsulates SBML Level/Version/namespaces
        information.  It is used to communicate the SBML Level, Version, and
        (in Level 3) packages used in addition to SBML Level 3 Core.  A common
        approach to using libSBML's SBMLNamespaces facilities is to create an
        SBMLNamespaces object somewhere in a program once, then hand that
        object as needed to object constructors that accept SBMLNamespaces as
        arguments.

        Parameter 'uri' is the URI of the SBML Level 3 package implemented by
        this libSBML package extension.

        Parameter 'prefix' is the XML namespace prefix being used for the
        package.

        Parameter 'layoutns' is the namespaces object for the package.

        ______________________________________________________________________
        Method variant with the following signature:

            LayoutSpeciesReferencePlugin(LayoutSpeciesReferencePlugin
        orig)

        Copy constructor. Creates a copy of this SBase object.

        Parameter 'orig' is the instance to copy.

        """
        this = _libsbml.new_LayoutSpeciesReferencePlugin(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_LayoutSpeciesReferencePlugin
    __del__ = lambda self: None

    def clone(self):
        """
        clone(LayoutSpeciesReferencePlugin self) -> LayoutSpeciesReferencePlugin


        Creates and returns a deep copy of this LayoutSpeciesReferencePlugin
        object.

        Returns a (deep) copy of this LayoutSpeciesReferencePlugin object.

        """
        return _libsbml.LayoutSpeciesReferencePlugin_clone(self)

LayoutSpeciesReferencePlugin_swigregister = _libsbml.LayoutSpeciesReferencePlugin_swigregister
LayoutSpeciesReferencePlugin_swigregister(LayoutSpeciesReferencePlugin)


def parseLayoutAnnotation(annotation, layouts):
    """
    parseLayoutAnnotation(XMLNode annotation, ListOfLayouts layouts)


    takes an annotation that has been read into the model identifies the
    RDF elements and creates a List of Layouts from the annotation

    """
    return _libsbml.parseLayoutAnnotation(annotation, layouts)

def deleteLayoutAnnotation(pAnnotation):
    """
    deleteLayoutAnnotation(XMLNode pAnnotation) -> XMLNode


    Takes an XMLNode and tries to find the layout annotation node and
    deletes it if it was found.

    """
    return _libsbml.deleteLayoutAnnotation(pAnnotation)

def parseLayouts(pModel):
    """
    parseLayouts(Model pModel) -> XMLNode


    Creates an XMLNode that represents the layouts of the model from the
    given Model object.

    """
    return _libsbml.parseLayouts(pModel)

def parseSpeciesReferenceAnnotation(annotation, sr):
    """
    parseSpeciesReferenceAnnotation(XMLNode annotation, SimpleSpeciesReference sr)


    takes an annotation that has been read into the species reference
    identifies the id elements and set the id of the species reference

    """
    return _libsbml.parseSpeciesReferenceAnnotation(annotation, sr)

def deleteLayoutIdAnnotation(pAnnotation):
    """
    deleteLayoutIdAnnotation(XMLNode pAnnotation) -> XMLNode


    Takes an XMLNode and tries to find the layoutId annotation node and
    deletes it if it was found.

    """
    return _libsbml.deleteLayoutIdAnnotation(pAnnotation)

def parseLayoutId(sr):
    """
    parseLayoutId(SimpleSpeciesReference sr) -> XMLNode


    Creates an XMLNode that represents the layoutId annotation of the
    species reference from the given SpeciesReference object.

    """
    return _libsbml.parseLayoutId(sr)
LayoutUnknownError = _libsbml.LayoutUnknownError
LayoutNSUndeclared = _libsbml.LayoutNSUndeclared
LayoutElementNotInNs = _libsbml.LayoutElementNotInNs
LayoutDuplicateComponentId = _libsbml.LayoutDuplicateComponentId
LayoutSIdSyntax = _libsbml.LayoutSIdSyntax
LayoutXsiTypeAllowedLocations = _libsbml.LayoutXsiTypeAllowedLocations
LayoutXsiTypeSyntax = _libsbml.LayoutXsiTypeSyntax
LayoutAttributeRequiredMissing = _libsbml.LayoutAttributeRequiredMissing
LayoutAttributeRequiredMustBeBoolean = _libsbml.LayoutAttributeRequiredMustBeBoolean
LayoutRequiredFalse = _libsbml.LayoutRequiredFalse
LayoutOnlyOneLOLayouts = _libsbml.LayoutOnlyOneLOLayouts
LayoutLOLayoutsNotEmpty = _libsbml.LayoutLOLayoutsNotEmpty
LayoutLOLayoutsAllowedElements = _libsbml.LayoutLOLayoutsAllowedElements
LayoutLOLayoutsAllowedAttributes = _libsbml.LayoutLOLayoutsAllowedAttributes
LayoutLayoutAllowedElements = _libsbml.LayoutLayoutAllowedElements
LayoutLayoutAllowedCoreAttributes = _libsbml.LayoutLayoutAllowedCoreAttributes
LayoutOnlyOneEachListOf = _libsbml.LayoutOnlyOneEachListOf
LayoutNoEmptyListOfs = _libsbml.LayoutNoEmptyListOfs
LayoutLayoutAllowedAttributes = _libsbml.LayoutLayoutAllowedAttributes
LayoutLayoutNameMustBeString = _libsbml.LayoutLayoutNameMustBeString
LayoutLOCompGlyphAllowedAttributes = _libsbml.LayoutLOCompGlyphAllowedAttributes
LayoutLOCompGlyphAllowedElements = _libsbml.LayoutLOCompGlyphAllowedElements
LayoutLOSpeciesGlyphAllowedAttributes = _libsbml.LayoutLOSpeciesGlyphAllowedAttributes
LayoutLOSpeciesGlyphAllowedElements = _libsbml.LayoutLOSpeciesGlyphAllowedElements
LayoutLORnGlyphAllowedAttributes = _libsbml.LayoutLORnGlyphAllowedAttributes
LayoutLORnGlyphAllowedElements = _libsbml.LayoutLORnGlyphAllowedElements
LayoutLOAddGOAllowedAttribut = _libsbml.LayoutLOAddGOAllowedAttribut
LayoutLOAddGOAllowedElements = _libsbml.LayoutLOAddGOAllowedElements
LayoutLayoutMustHaveDimensions = _libsbml.LayoutLayoutMustHaveDimensions
LayoutLOTextGlyphAllowedAttributes = _libsbml.LayoutLOTextGlyphAllowedAttributes
LayoutLOTextGlyphAllowedElements = _libsbml.LayoutLOTextGlyphAllowedElements
LayoutGOAllowedCoreElements = _libsbml.LayoutGOAllowedCoreElements
LayoutGOAllowedCoreAttributes = _libsbml.LayoutGOAllowedCoreAttributes
LayoutGOAllowedElements = _libsbml.LayoutGOAllowedElements
LayoutGOAllowedAttributes = _libsbml.LayoutGOAllowedAttributes
LayoutGOMetaIdRefMustBeIDREF = _libsbml.LayoutGOMetaIdRefMustBeIDREF
LayoutGOMetaIdRefMustReferenceObject = _libsbml.LayoutGOMetaIdRefMustReferenceObject
LayoutGOMustContainBoundingBox = _libsbml.LayoutGOMustContainBoundingBox
LayoutCGAllowedCoreElements = _libsbml.LayoutCGAllowedCoreElements
LayoutCGAllowedCoreAttributes = _libsbml.LayoutCGAllowedCoreAttributes
LayoutCGAllowedElements = _libsbml.LayoutCGAllowedElements
LayoutCGAllowedAttributes = _libsbml.LayoutCGAllowedAttributes
LayoutCGMetaIdRefMustBeIDREF = _libsbml.LayoutCGMetaIdRefMustBeIDREF
LayoutCGMetaIdRefMustReferenceObject = _libsbml.LayoutCGMetaIdRefMustReferenceObject
LayoutCGCompartmentSyntax = _libsbml.LayoutCGCompartmentSyntax
LayoutCGCompartmentMustRefComp = _libsbml.LayoutCGCompartmentMustRefComp
LayoutCGNoDuplicateReferences = _libsbml.LayoutCGNoDuplicateReferences
LayoutCGOrderMustBeDouble = _libsbml.LayoutCGOrderMustBeDouble
LayoutSGAllowedCoreElements = _libsbml.LayoutSGAllowedCoreElements
LayoutSGAllowedCoreAttributes = _libsbml.LayoutSGAllowedCoreAttributes
LayoutSGAllowedElements = _libsbml.LayoutSGAllowedElements
LayoutSGAllowedAttributes = _libsbml.LayoutSGAllowedAttributes
LayoutSGMetaIdRefMustBeIDREF = _libsbml.LayoutSGMetaIdRefMustBeIDREF
LayoutSGMetaIdRefMustReferenceObject = _libsbml.LayoutSGMetaIdRefMustReferenceObject
LayoutSGSpeciesSyntax = _libsbml.LayoutSGSpeciesSyntax
LayoutSGSpeciesMustRefSpecies = _libsbml.LayoutSGSpeciesMustRefSpecies
LayoutSGNoDuplicateReferences = _libsbml.LayoutSGNoDuplicateReferences
LayoutRGAllowedCoreElements = _libsbml.LayoutRGAllowedCoreElements
LayoutRGAllowedCoreAttributes = _libsbml.LayoutRGAllowedCoreAttributes
LayoutRGAllowedElements = _libsbml.LayoutRGAllowedElements
LayoutRGAllowedAttributes = _libsbml.LayoutRGAllowedAttributes
LayoutRGMetaIdRefMustBeIDREF = _libsbml.LayoutRGMetaIdRefMustBeIDREF
LayoutRGMetaIdRefMustReferenceObject = _libsbml.LayoutRGMetaIdRefMustReferenceObject
LayoutRGReactionSyntax = _libsbml.LayoutRGReactionSyntax
LayoutRGReactionMustRefReaction = _libsbml.LayoutRGReactionMustRefReaction
LayoutRGNoDuplicateReferences = _libsbml.LayoutRGNoDuplicateReferences
LayoutLOSpeciesRefGlyphAllowedElements = _libsbml.LayoutLOSpeciesRefGlyphAllowedElements
LayoutLOSpeciesRefGlyphAllowedAttribs = _libsbml.LayoutLOSpeciesRefGlyphAllowedAttribs
LayoutLOSpeciesRefGlyphNotEmpty = _libsbml.LayoutLOSpeciesRefGlyphNotEmpty
LayoutGGAllowedCoreElements = _libsbml.LayoutGGAllowedCoreElements
LayoutGGAllowedCoreAttributes = _libsbml.LayoutGGAllowedCoreAttributes
LayoutGGAllowedElements = _libsbml.LayoutGGAllowedElements
LayoutGGAllowedAttributes = _libsbml.LayoutGGAllowedAttributes
LayoutGGMetaIdRefMustBeIDREF = _libsbml.LayoutGGMetaIdRefMustBeIDREF
LayoutGGMetaIdRefMustReferenceObject = _libsbml.LayoutGGMetaIdRefMustReferenceObject
LayoutGGReferenceSyntax = _libsbml.LayoutGGReferenceSyntax
LayoutGGReferenceMustRefObject = _libsbml.LayoutGGReferenceMustRefObject
LayoutGGNoDuplicateReferences = _libsbml.LayoutGGNoDuplicateReferences
LayoutLOReferenceGlyphAllowedElements = _libsbml.LayoutLOReferenceGlyphAllowedElements
LayoutLOReferenceGlyphAllowedAttribs = _libsbml.LayoutLOReferenceGlyphAllowedAttribs
LayoutLOSubGlyphAllowedElements = _libsbml.LayoutLOSubGlyphAllowedElements
LayoutLOSubGlyphAllowedAttribs = _libsbml.LayoutLOSubGlyphAllowedAttribs
LayoutTGAllowedCoreElements = _libsbml.LayoutTGAllowedCoreElements
LayoutTGAllowedCoreAttributes = _libsbml.LayoutTGAllowedCoreAttributes
LayoutTGAllowedElements = _libsbml.LayoutTGAllowedElements
LayoutTGAllowedAttributes = _libsbml.LayoutTGAllowedAttributes
LayoutTGMetaIdRefMustBeIDREF = _libsbml.LayoutTGMetaIdRefMustBeIDREF
LayoutTGMetaIdRefMustReferenceObject = _libsbml.LayoutTGMetaIdRefMustReferenceObject
LayoutTGOriginOfTextSyntax = _libsbml.LayoutTGOriginOfTextSyntax
LayoutTGOriginOfTextMustRefObject = _libsbml.LayoutTGOriginOfTextMustRefObject
LayoutTGNoDuplicateReferences = _libsbml.LayoutTGNoDuplicateReferences
LayoutTGGraphicalObjectSyntax = _libsbml.LayoutTGGraphicalObjectSyntax
LayoutTGGraphicalObjectMustRefObject = _libsbml.LayoutTGGraphicalObjectMustRefObject
LayoutTGTextMustBeString = _libsbml.LayoutTGTextMustBeString
LayoutSRGAllowedCoreElements = _libsbml.LayoutSRGAllowedCoreElements
LayoutSRGAllowedCoreAttributes = _libsbml.LayoutSRGAllowedCoreAttributes
LayoutSRGAllowedElements = _libsbml.LayoutSRGAllowedElements
LayoutSRGAllowedAttributes = _libsbml.LayoutSRGAllowedAttributes
LayoutSRGMetaIdRefMustBeIDREF = _libsbml.LayoutSRGMetaIdRefMustBeIDREF
LayoutSRGMetaIdRefMustReferenceObject = _libsbml.LayoutSRGMetaIdRefMustReferenceObject
LayoutSRGSpeciesReferenceSyntax = _libsbml.LayoutSRGSpeciesReferenceSyntax
LayoutSRGSpeciesRefMustRefObject = _libsbml.LayoutSRGSpeciesRefMustRefObject
LayoutSRGNoDuplicateReferences = _libsbml.LayoutSRGNoDuplicateReferences
LayoutSRGSpeciesGlyphSyntax = _libsbml.LayoutSRGSpeciesGlyphSyntax
LayoutSRGSpeciesGlyphMustRefObject = _libsbml.LayoutSRGSpeciesGlyphMustRefObject
LayoutSRGRoleSyntax = _libsbml.LayoutSRGRoleSyntax
LayoutREFGAllowedCoreElements = _libsbml.LayoutREFGAllowedCoreElements
LayoutREFGAllowedCoreAttributes = _libsbml.LayoutREFGAllowedCoreAttributes
LayoutREFGAllowedElements = _libsbml.LayoutREFGAllowedElements
LayoutREFGAllowedAttributes = _libsbml.LayoutREFGAllowedAttributes
LayoutREFGMetaIdRefMustBeIDREF = _libsbml.LayoutREFGMetaIdRefMustBeIDREF
LayoutREFGMetaIdRefMustReferenceObject = _libsbml.LayoutREFGMetaIdRefMustReferenceObject
LayoutREFGReferenceSyntax = _libsbml.LayoutREFGReferenceSyntax
LayoutREFGReferenceMustRefObject = _libsbml.LayoutREFGReferenceMustRefObject
LayoutREFGNoDuplicateReferences = _libsbml.LayoutREFGNoDuplicateReferences
LayoutREFGGlyphSyntax = _libsbml.LayoutREFGGlyphSyntax
LayoutREFGGlyphMustRefObject = _libsbml.LayoutREFGGlyphMustRefObject
LayoutREFGRoleSyntax = _libsbml.LayoutREFGRoleSyntax
LayoutPointAllowedCoreElements = _libsbml.LayoutPointAllowedCoreElements
LayoutPointAllowedCoreAttributes = _libsbml.LayoutPointAllowedCoreAttributes
LayoutPointAllowedAttributes = _libsbml.LayoutPointAllowedAttributes
LayoutPointAttributesMustBeDouble = _libsbml.LayoutPointAttributesMustBeDouble
LayoutBBoxAllowedCoreElements = _libsbml.LayoutBBoxAllowedCoreElements
LayoutBBoxAllowedCoreAttributes = _libsbml.LayoutBBoxAllowedCoreAttributes
LayoutBBoxAllowedElements = _libsbml.LayoutBBoxAllowedElements
LayoutBBoxAllowedAttributes = _libsbml.LayoutBBoxAllowedAttributes
LayoutBBoxConsistent3DDefinition = _libsbml.LayoutBBoxConsistent3DDefinition
LayoutCurveAllowedCoreElements = _libsbml.LayoutCurveAllowedCoreElements
LayoutCurveAllowedCoreAttributes = _libsbml.LayoutCurveAllowedCoreAttributes
LayoutCurveAllowedElements = _libsbml.LayoutCurveAllowedElements
LayoutCurveAllowedAttributes = _libsbml.LayoutCurveAllowedAttributes
LayoutLOCurveSegsAllowedAttributes = _libsbml.LayoutLOCurveSegsAllowedAttributes
LayoutLOCurveSegsAllowedElements = _libsbml.LayoutLOCurveSegsAllowedElements
LayoutLOCurveSegsNotEmpty = _libsbml.LayoutLOCurveSegsNotEmpty
LayoutLSegAllowedCoreElements = _libsbml.LayoutLSegAllowedCoreElements
LayoutLSegAllowedCoreAttributes = _libsbml.LayoutLSegAllowedCoreAttributes
LayoutLSegAllowedElements = _libsbml.LayoutLSegAllowedElements
LayoutLSegAllowedAttributes = _libsbml.LayoutLSegAllowedAttributes
LayoutCBezAllowedCoreElements = _libsbml.LayoutCBezAllowedCoreElements
LayoutCBezAllowedCoreAttributes = _libsbml.LayoutCBezAllowedCoreAttributes
LayoutCBezAllowedElements = _libsbml.LayoutCBezAllowedElements
LayoutCBezAllowedAttributes = _libsbml.LayoutCBezAllowedAttributes
LayoutDimsAllowedCoreElements = _libsbml.LayoutDimsAllowedCoreElements
LayoutDimsAllowedCoreAttributes = _libsbml.LayoutDimsAllowedCoreAttributes
LayoutDimsAllowedAttributes = _libsbml.LayoutDimsAllowedAttributes
LayoutDimsAttributesMustBeDouble = _libsbml.LayoutDimsAttributesMustBeDouble
class LayoutPkgNamespaces(SBMLNamespaces):
    """

    Set of SBML Level + Version + namespace triples.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    SBMLExtensionNamespaces is a template class.  It is extended from
    SBMLNamespaces and is meant to be used by package extensions to store
    the SBML Level, Version within a Level, and package version of the
    SBML Level 3 package implemented by a libSBML package extension.

    Basic principles of SBML package extensions in libSBML
    ======================================================================

    SBML Level 3's package structure permits modular extensions to the
    core SBML format.  In libSBML, support for SBML Level 3 packages is
    provided through optional package extensions that can be plugged into
    libSBML at the time it is built/compiled.  Users of libSBML can thus
    choose which extensions are enabled in their software applications.

    LibSBML defines a number of classes that developers of package
    extensions can use to implement support for an SBML Level 3 package.
    These classes make it easier to extend libSBML objects with new
    attributes and/or subobjects as needed by a particular Level 3
    package. Three overall categories of classes make up libSBML's
    facilities for implementing package extensions.  There are (1) classes
    that serve as base classes meant to be subclassed, (2) template
    classes meant to be instantiated rather than subclassed, and (3)
    support classes that provide utility features. A given package
    implementation for libSBML will take the form of code using these and
    other libSBML classes, placed in a subdirectory of src/sbml/packages/.

    The basic libSBML distribution includes a number of package extensions
    implementing support for officially-endorsed SBML Level 3 packages;
    among these are Flux Balance Constraints ('fbc'), Hierarchical Model
    Composition ('comp'), Layout ('layout'), and Qualitative Models
    ('qual').  They can serve as working examples for developers working
    to implement other packages.

    Extensions in libSBML can currently only be implemented in C++ or C;
    there is no mechanism to implement them first in languages such as
    Java or Python.  However, once implemented in C++ or C, language
    interfaces can be generated semi-automatically using the framework in
    place in libSBML.  (The approach is based on using SWIG and facilities
    in libSBML's build system.)

    """

    __swig_setmethods__ = {}
    for _s in [SBMLNamespaces]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LayoutPkgNamespaces, name, value)
    __swig_getmethods__ = {}
    for _s in [SBMLNamespaces]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, LayoutPkgNamespaces, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_LayoutPkgNamespaces
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(SBMLExtensionNamespaces<(LayoutExtension)> self, unsigned int level, unsigned int version, unsigned int pkgVersion, string prefix) -> LayoutPkgNamespaces
        __init__(SBMLExtensionNamespaces<(LayoutExtension)> self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> LayoutPkgNamespaces
        __init__(SBMLExtensionNamespaces<(LayoutExtension)> self, unsigned int level, unsigned int version) -> LayoutPkgNamespaces
        __init__(SBMLExtensionNamespaces<(LayoutExtension)> self, unsigned int level) -> LayoutPkgNamespaces
        __init__(SBMLExtensionNamespaces<(LayoutExtension)> self) -> LayoutPkgNamespaces
        __init__(SBMLExtensionNamespaces<(LayoutExtension)> self, LayoutPkgNamespaces orig) -> LayoutPkgNamespaces


        Set of SBML Level + Version + namespace triples.

        This class of objects is defined by libSBML only and has no direct
        equivalent in terms of SBML components.  This class is not prescribed
        by the SBML specifications, although it is used to implement features
        defined in SBML.

        SBMLExtensionNamespaces is a template class.  It is extended from
        SBMLNamespaces and is meant to be used by package extensions to store
        the SBML Level, Version within a Level, and package version of the
        SBML Level 3 package implemented by a libSBML package extension.

        Basic principles of SBML package extensions in libSBML
        ======================================================================

        SBML Level 3's package structure permits modular extensions to the
        core SBML format.  In libSBML, support for SBML Level 3 packages is
        provided through optional package extensions that can be plugged into
        libSBML at the time it is built/compiled.  Users of libSBML can thus
        choose which extensions are enabled in their software applications.

        LibSBML defines a number of classes that developers of package
        extensions can use to implement support for an SBML Level 3 package.
        These classes make it easier to extend libSBML objects with new
        attributes and/or subobjects as needed by a particular Level 3
        package. Three overall categories of classes make up libSBML's
        facilities for implementing package extensions.  There are (1) classes
        that serve as base classes meant to be subclassed, (2) template
        classes meant to be instantiated rather than subclassed, and (3)
        support classes that provide utility features. A given package
        implementation for libSBML will take the form of code using these and
        other libSBML classes, placed in a subdirectory of src/sbml/packages/.

        The basic libSBML distribution includes a number of package extensions
        implementing support for officially-endorsed SBML Level 3 packages;
        among these are Flux Balance Constraints ('fbc'), Hierarchical Model
        Composition ('comp'), Layout ('layout'), and Qualitative Models
        ('qual').  They can serve as working examples for developers working
        to implement other packages.

        Extensions in libSBML can currently only be implemented in C++ or C;
        there is no mechanism to implement them first in languages such as
        Java or Python.  However, once implemented in C++ or C, language
        interfaces can be generated semi-automatically using the framework in
        place in libSBML.  (The approach is based on using SWIG and facilities
        in libSBML's build system.)

        """
        this = _libsbml.new_LayoutPkgNamespaces(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(LayoutPkgNamespaces self) -> ISBMLExtensionNamespaces


        Creates and returns a deep copy of this SBMLNamespaces object.

        Returns the (deep) copy of this SBMLNamespaces object.

        """
        return _libsbml.LayoutPkgNamespaces_clone(self)


    def getURI(self):
        """
        getURI(LayoutPkgNamespaces self) -> string


        Returns a string representing the SBML XML namespace of this object.

        Returns a string representing the SBML namespace that reflects the
        SBML Level and Version of this object.

        """
        return _libsbml.LayoutPkgNamespaces_getURI(self)


    def getPackageVersion(self):
        """getPackageVersion(LayoutPkgNamespaces self) -> unsigned int"""
        return _libsbml.LayoutPkgNamespaces_getPackageVersion(self)


    def getPackageName(self):
        """
        getPackageName(LayoutPkgNamespaces self) -> string


        Returns the name of the main package for this namespace.

        Returns the name of the main package for this namespace. 'core' will
        be returned if this namespace is defined in the SBML  core.

        """
        return _libsbml.LayoutPkgNamespaces_getPackageName(self)

LayoutPkgNamespaces_swigregister = _libsbml.LayoutPkgNamespaces_swigregister
LayoutPkgNamespaces_swigregister(LayoutPkgNamespaces)

class MultiPkgNamespaces(SBMLNamespaces):
    """

    Set of SBML Level + Version + namespace triples.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    SBMLExtensionNamespaces is a template class.  It is extended from
    SBMLNamespaces and is meant to be used by package extensions to store
    the SBML Level, Version within a Level, and package version of the
    SBML Level 3 package implemented by a libSBML package extension.

    Basic principles of SBML package extensions in libSBML
    ======================================================================

    SBML Level 3's package structure permits modular extensions to the
    core SBML format.  In libSBML, support for SBML Level 3 packages is
    provided through optional package extensions that can be plugged into
    libSBML at the time it is built/compiled.  Users of libSBML can thus
    choose which extensions are enabled in their software applications.

    LibSBML defines a number of classes that developers of package
    extensions can use to implement support for an SBML Level 3 package.
    These classes make it easier to extend libSBML objects with new
    attributes and/or subobjects as needed by a particular Level 3
    package. Three overall categories of classes make up libSBML's
    facilities for implementing package extensions.  There are (1) classes
    that serve as base classes meant to be subclassed, (2) template
    classes meant to be instantiated rather than subclassed, and (3)
    support classes that provide utility features. A given package
    implementation for libSBML will take the form of code using these and
    other libSBML classes, placed in a subdirectory of src/sbml/packages/.

    The basic libSBML distribution includes a number of package extensions
    implementing support for officially-endorsed SBML Level 3 packages;
    among these are Flux Balance Constraints ('fbc'), Hierarchical Model
    Composition ('comp'), Layout ('layout'), and Qualitative Models
    ('qual').  They can serve as working examples for developers working
    to implement other packages.

    Extensions in libSBML can currently only be implemented in C++ or C;
    there is no mechanism to implement them first in languages such as
    Java or Python.  However, once implemented in C++ or C, language
    interfaces can be generated semi-automatically using the framework in
    place in libSBML.  (The approach is based on using SWIG and facilities
    in libSBML's build system.)

    """

    __swig_setmethods__ = {}
    for _s in [SBMLNamespaces]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MultiPkgNamespaces, name, value)
    __swig_getmethods__ = {}
    for _s in [SBMLNamespaces]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, MultiPkgNamespaces, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_MultiPkgNamespaces
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(SBMLExtensionNamespaces<(MultiExtension)> self, unsigned int level, unsigned int version, unsigned int pkgVersion, string prefix) -> MultiPkgNamespaces
        __init__(SBMLExtensionNamespaces<(MultiExtension)> self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> MultiPkgNamespaces
        __init__(SBMLExtensionNamespaces<(MultiExtension)> self, unsigned int level, unsigned int version) -> MultiPkgNamespaces
        __init__(SBMLExtensionNamespaces<(MultiExtension)> self, unsigned int level) -> MultiPkgNamespaces
        __init__(SBMLExtensionNamespaces<(MultiExtension)> self) -> MultiPkgNamespaces
        __init__(SBMLExtensionNamespaces<(MultiExtension)> self, MultiPkgNamespaces orig) -> MultiPkgNamespaces


        Set of SBML Level + Version + namespace triples.

        This class of objects is defined by libSBML only and has no direct
        equivalent in terms of SBML components.  This class is not prescribed
        by the SBML specifications, although it is used to implement features
        defined in SBML.

        SBMLExtensionNamespaces is a template class.  It is extended from
        SBMLNamespaces and is meant to be used by package extensions to store
        the SBML Level, Version within a Level, and package version of the
        SBML Level 3 package implemented by a libSBML package extension.

        Basic principles of SBML package extensions in libSBML
        ======================================================================

        SBML Level 3's package structure permits modular extensions to the
        core SBML format.  In libSBML, support for SBML Level 3 packages is
        provided through optional package extensions that can be plugged into
        libSBML at the time it is built/compiled.  Users of libSBML can thus
        choose which extensions are enabled in their software applications.

        LibSBML defines a number of classes that developers of package
        extensions can use to implement support for an SBML Level 3 package.
        These classes make it easier to extend libSBML objects with new
        attributes and/or subobjects as needed by a particular Level 3
        package. Three overall categories of classes make up libSBML's
        facilities for implementing package extensions.  There are (1) classes
        that serve as base classes meant to be subclassed, (2) template
        classes meant to be instantiated rather than subclassed, and (3)
        support classes that provide utility features. A given package
        implementation for libSBML will take the form of code using these and
        other libSBML classes, placed in a subdirectory of src/sbml/packages/.

        The basic libSBML distribution includes a number of package extensions
        implementing support for officially-endorsed SBML Level 3 packages;
        among these are Flux Balance Constraints ('fbc'), Hierarchical Model
        Composition ('comp'), Layout ('layout'), and Qualitative Models
        ('qual').  They can serve as working examples for developers working
        to implement other packages.

        Extensions in libSBML can currently only be implemented in C++ or C;
        there is no mechanism to implement them first in languages such as
        Java or Python.  However, once implemented in C++ or C, language
        interfaces can be generated semi-automatically using the framework in
        place in libSBML.  (The approach is based on using SWIG and facilities
        in libSBML's build system.)

        """
        this = _libsbml.new_MultiPkgNamespaces(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(MultiPkgNamespaces self) -> ISBMLExtensionNamespaces


        Creates and returns a deep copy of this SBMLNamespaces object.

        Returns the (deep) copy of this SBMLNamespaces object.

        """
        return _libsbml.MultiPkgNamespaces_clone(self)


    def getURI(self):
        """
        getURI(MultiPkgNamespaces self) -> string


        Returns a string representing the SBML XML namespace of this object.

        Returns a string representing the SBML namespace that reflects the
        SBML Level and Version of this object.

        """
        return _libsbml.MultiPkgNamespaces_getURI(self)


    def getPackageVersion(self):
        """getPackageVersion(MultiPkgNamespaces self) -> unsigned int"""
        return _libsbml.MultiPkgNamespaces_getPackageVersion(self)


    def getPackageName(self):
        """
        getPackageName(MultiPkgNamespaces self) -> string


        Returns the name of the main package for this namespace.

        Returns the name of the main package for this namespace. 'core' will
        be returned if this namespace is defined in the SBML  core.

        """
        return _libsbml.MultiPkgNamespaces_getPackageName(self)

MultiPkgNamespaces_swigregister = _libsbml.MultiPkgNamespaces_swigregister
MultiPkgNamespaces_swigregister(MultiPkgNamespaces)

class MultiExtension(SBMLExtension):
    """

    [SBML 'multi' package]  Base extension class for the package.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    This is the Multistate, Multicomponent and Multicompartment Species
    package extension of the SBMLExtension class.  This is a class that
    every libSBML plug-in must implement in order to implement an SBML
    Level 3 package.

    """

    __swig_setmethods__ = {}
    for _s in [SBMLExtension]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MultiExtension, name, value)
    __swig_getmethods__ = {}
    for _s in [SBMLExtension]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, MultiExtension, name)
    __repr__ = _swig_repr

    def getPackageName():
        """
        getPackageName() -> string


        Returns the nickname of the SBML Level 3 package implemented by this
        libSBML extension.

        Returns the package nickname, as a string.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.MultiExtension_getPackageName()

    getPackageName = staticmethod(getPackageName)

    def getDefaultLevel():
        """
        getDefaultLevel() -> unsigned int


        Returns the default SBML Level used by this libSBML package extension.

        Returns the SBML Level.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.MultiExtension_getDefaultLevel()

    getDefaultLevel = staticmethod(getDefaultLevel)

    def getDefaultVersion():
        """
        getDefaultVersion() -> unsigned int


        Returns the default SBML Version used by this libSBML package
        extension.

        Returns the Version within the default SBML Level.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.MultiExtension_getDefaultVersion()

    getDefaultVersion = staticmethod(getDefaultVersion)

    def getDefaultPackageVersion():
        """
        getDefaultPackageVersion() -> unsigned int


        Returns the default version of the SBML Level 3 package implemented by
        this libSBML extension.

        Returns the default version number of the SBML Level 3 package
        definition.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.MultiExtension_getDefaultPackageVersion()

    getDefaultPackageVersion = staticmethod(getDefaultPackageVersion)

    def getXmlnsL3V1V1():
        """
        getXmlnsL3V1V1() -> string


        Returns the XML namespace URI of the SBML Level 3 package implemented
        by this libSBML extension.

        Returns the XML namespace as a string.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.MultiExtension_getXmlnsL3V1V1()

    getXmlnsL3V1V1 = staticmethod(getXmlnsL3V1V1)

    def __init__(self, *args):
        """
        __init__(MultiExtension self) -> MultiExtension
        __init__(MultiExtension self, MultiExtension orig) -> MultiExtension


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            MultiExtension(MultiExtension orig)

        Copy constructor for MultiExtension.

        Parameter 'orig' is the instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            MultiExtension()

        Creates a new MultiExtension instance.

        """
        this = _libsbml.new_MultiExtension(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(MultiExtension self) -> MultiExtension


        Creates and returns a deep copy of this MultiExtension object.

        Returns a (deep) copy of this MultiExtension object.

        """
        return _libsbml.MultiExtension_clone(self)

    __swig_destroy__ = _libsbml.delete_MultiExtension
    __del__ = lambda self: None

    def getName(self):
        """
        getName(MultiExtension self) -> string


        Returns the name of this package ('multi')

        Returns a string representing the name of this package ('multi')

        """
        return _libsbml.MultiExtension_getName(self)


    def getURI(self, sbmlLevel, sbmlVersion, pkgVersion):
        """
        getURI(MultiExtension self, unsigned int sbmlLevel, unsigned int sbmlVersion, unsigned int pkgVersion) -> string


        Returns a string representing the SBML XML namespace of this SBML
        Level 3 package.

        The namespace URI constructed by this method corresponds to the
        combination of the Level and Version of SBML, and the Version of the
        SBML Level 3 package. (At the time of this writing, the only SBML
        Level that supports packages is Level 3, so the value of 'sbmlLevel'
        must necessarily always be 3.)

        Parameter 'sbmlLevel' is the level of SBML. Parameter 'sbmlVersion' is
        the version of SBML. Parameter 'pkgVersion' is the version of the
        package.

        Returns a string of the package URI, or an empty string if no
        corresponding URI exists.

        """
        return _libsbml.MultiExtension_getURI(self, sbmlLevel, sbmlVersion, pkgVersion)


    def getLevel(self, uri):
        """
        getLevel(MultiExtension self, string uri) -> unsigned int


        Returns the SBML Level for the given URI of this package.

        Parameter 'uri' is a URI that represents a version of this package.

        Returns the SBML Level for the given URI of this package, or '0' if
        the given URI is invalid, or for a different package.

        """
        return _libsbml.MultiExtension_getLevel(self, uri)


    def getVersion(self, uri):
        """
        getVersion(MultiExtension self, string uri) -> unsigned int


        Returns the Version within the SBML Level for the given URI of this
        package.

        Parameter 'uri' is a URI that represents a version of this package.

        Returns the SBML Version within the SBML Level for the given URI of
        this package, or '0' if the given URI is invalid, or for a different
        package.

        """
        return _libsbml.MultiExtension_getVersion(self, uri)


    def getPackageVersion(self, uri):
        """
        getPackageVersion(MultiExtension self, string uri) -> unsigned int


        Returns the SBML Level 3 package version for the given URI of this
        package.

        Parameter 'uri' is a URI that represents one of the valid versions of
        this package.

        Returns the version of the SBML Level 3 package with the given URI, or
        '0' if the given URI is invalid, or for a different package.

        """
        return _libsbml.MultiExtension_getPackageVersion(self, uri)


    def getSBMLExtensionNamespaces(self, uri):
        """
        getSBMLExtensionNamespaces(MultiExtension self, string uri) -> SBMLNamespaces


        Returns a MultiPkgNamespaces object.

        Parameter 'uri' is a URI that represents one of the valid versions of
        the 'multi' package.

        Returns a MultiPkgNamespaces object corresponding to the given 'uri',
        or 'None' if the URI is not defined in the Multi package.

        """
        return _libsbml.MultiExtension_getSBMLExtensionNamespaces(self, uri)


    def getStringFromTypeCode(self, typeCode):
        """
        getStringFromTypeCode(MultiExtension self, int typeCode) -> char const *


        Takes a type code of the 'multi' package and returns a string
        describing the code.

        Parameter 'typeCode' is a libSBML type code defined by the libSBML
        extension. implementing support for the SBML Level 3 'multi' package.

        Returns a text string representing the type code given by 'typeCode'.
        If the type code is unrecognized for this implementation of the
        libSBML 'multi' package, the string returned will be '(Unknown SBML
        Multi Type)'.

        """
        return _libsbml.MultiExtension_getStringFromTypeCode(self, typeCode)


    def init():
        """
        init()


        Internal implementation method.

        """
        return _libsbml.MultiExtension_init()

    init = staticmethod(init)

    def getErrorTable(self, index):
        """
        getErrorTable(MultiExtension self, unsigned int index) -> packageErrorTableEntry


        Internal implementation method.

        """
        return _libsbml.MultiExtension_getErrorTable(self, index)


    def getErrorTableIndex(self, errorId):
        """
        getErrorTableIndex(MultiExtension self, unsigned int errorId) -> unsigned int


        Internal implementation method.

        """
        return _libsbml.MultiExtension_getErrorTableIndex(self, errorId)


    def getErrorIdOffset(self):
        """
        getErrorIdOffset(MultiExtension self) -> unsigned int


        Internal implementation method.

        """
        return _libsbml.MultiExtension_getErrorIdOffset(self)

MultiExtension_swigregister = _libsbml.MultiExtension_swigregister
MultiExtension_swigregister(MultiExtension)

def MultiExtension_getPackageName():
    """
    MultiExtension_getPackageName() -> string


    Returns the nickname of the SBML Level 3 package implemented by this
    libSBML extension.

    Returns the package nickname, as a string.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.MultiExtension_getPackageName()

def MultiExtension_getDefaultLevel():
    """
    MultiExtension_getDefaultLevel() -> unsigned int


    Returns the default SBML Level used by this libSBML package extension.

    Returns the SBML Level.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.MultiExtension_getDefaultLevel()

def MultiExtension_getDefaultVersion():
    """
    MultiExtension_getDefaultVersion() -> unsigned int


    Returns the default SBML Version used by this libSBML package
    extension.

    Returns the Version within the default SBML Level.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.MultiExtension_getDefaultVersion()

def MultiExtension_getDefaultPackageVersion():
    """
    MultiExtension_getDefaultPackageVersion() -> unsigned int


    Returns the default version of the SBML Level 3 package implemented by
    this libSBML extension.

    Returns the default version number of the SBML Level 3 package
    definition.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.MultiExtension_getDefaultPackageVersion()

def MultiExtension_getXmlnsL3V1V1():
    """
    MultiExtension_getXmlnsL3V1V1() -> string


    Returns the XML namespace URI of the SBML Level 3 package implemented
    by this libSBML extension.

    Returns the XML namespace as a string.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.MultiExtension_getXmlnsL3V1V1()

def MultiExtension_init():
    """
    MultiExtension_init()


    Internal implementation method.

    """
    return _libsbml.MultiExtension_init()

SBML_MULTI_POSSIBLE_SPECIES_FEATURE_VALUE = _libsbml.SBML_MULTI_POSSIBLE_SPECIES_FEATURE_VALUE
SBML_MULTI_SPECIES_FEATURE_VALUE = _libsbml.SBML_MULTI_SPECIES_FEATURE_VALUE
SBML_MULTI_COMPARTMENT_REFERENCE = _libsbml.SBML_MULTI_COMPARTMENT_REFERENCE
SBML_MULTI_SPECIES_TYPE_INSTANCE = _libsbml.SBML_MULTI_SPECIES_TYPE_INSTANCE
SBML_MULTI_IN_SPECIES_TYPE_BOND = _libsbml.SBML_MULTI_IN_SPECIES_TYPE_BOND
SBML_MULTI_OUTWARD_BINDING_SITE = _libsbml.SBML_MULTI_OUTWARD_BINDING_SITE
SBML_MULTI_SPECIES_FEATURE_TYPE = _libsbml.SBML_MULTI_SPECIES_FEATURE_TYPE
SBML_MULTI_SPECIES_TYPE_COMPONENT_INDEX = _libsbml.SBML_MULTI_SPECIES_TYPE_COMPONENT_INDEX
SBML_MULTI_SPECIES_FEATURE = _libsbml.SBML_MULTI_SPECIES_FEATURE
SBML_MULTI_SPECIES_TYPE_COMPONENT_MAP_IN_PRODUCT = _libsbml.SBML_MULTI_SPECIES_TYPE_COMPONENT_MAP_IN_PRODUCT
SBML_MULTI_SPECIES_TYPE = _libsbml.SBML_MULTI_SPECIES_TYPE
SBML_MULTI_BINDING_SITE_SPECIES_TYPE = _libsbml.SBML_MULTI_BINDING_SITE_SPECIES_TYPE
SBML_MULTI_INTRA_SPECIES_REACTION = _libsbml.SBML_MULTI_INTRA_SPECIES_REACTION
SBML_MULTI_SUBLIST_OF_SPECIES_FEATURES = _libsbml.SBML_MULTI_SUBLIST_OF_SPECIES_FEATURES
class MultiSBMLDocumentPlugin(SBMLDocumentPlugin):
    """

    [SBML 'multi' package]  Extension of SBMLDocument for the 'multi'
    package.

    The MultiSBMLDocumentPlugin class inherits from the SBMLDocumentPlugin
    class, and codifies the extensions to the SBMLDocument class defined
    in the SBML Level 3  ('multi') package.  This extension defines a
    required flag named 'required', which indicates whether 'multi'
    constructs can be used to change the core mathematical interpretation
    of the Model defined in the SBML input.  Since 'multi' constructs can,
    this attribute must be set to the value ''True'.'

    """

    __swig_setmethods__ = {}
    for _s in [SBMLDocumentPlugin]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MultiSBMLDocumentPlugin, name, value)
    __swig_getmethods__ = {}
    for _s in [SBMLDocumentPlugin]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, MultiSBMLDocumentPlugin, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(MultiSBMLDocumentPlugin self, string uri, string prefix, MultiPkgNamespaces multins) -> MultiSBMLDocumentPlugin
        __init__(MultiSBMLDocumentPlugin self, MultiSBMLDocumentPlugin orig) -> MultiSBMLDocumentPlugin


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            MultiSBMLDocumentPlugin(string uri, string prefix,
        MultiPkgNamespaces multins)

        Creates a new MultiSBMLDocumentPlugin object.

        In the XML representation of an SBML document, XML namespaces are
        used to identify the origin of each XML construct used.  XML
        namespaces are identified by their unique resource identifiers (URIs).
        The core SBML specifications stipulate the namespaces that must be
        used for core SBML constructs; for example, all XML elements that
        belong to SBML Level 3 Version 1 Core must be placed in the XML
        namespace identified by the URI
        'http://www.sbml.org/sbml/level3/version1/core'.  Individual SBML
        Level 3 packages define their own XML namespaces; for example, all
        elements belonging to the SBML Level 3 Layout Version 1 package must
        be placed in the XML namespace
        'http://www.sbml.org/sbml/level3/version1/layout/version1/'.

        The SBMLNamespaces object encapsulates SBML Level/Version/namespaces
        information.  It is used to communicate the SBML Level, Version, and
        (in Level 3) packages used in addition to SBML Level 3 Core.  A common
        approach to using libSBML's SBMLNamespaces facilities is to create an
        SBMLNamespaces object somewhere in a program once, then hand that
        object as needed to object constructors that accept SBMLNamespaces as
        arguments.

        Parameter 'uri' is the URI of the SBML Level 3 package implemented by
        this libSBML package extension.

        Parameter 'prefix' is the XML namespace prefix being used for the
        package.

        Parameter 'multins' is the namespaces object for the package.

        ______________________________________________________________________
        Method variant with the following signature:

            MultiSBMLDocumentPlugin(MultiSBMLDocumentPlugin orig)

        Copy constructor for MultiSBMLDocumentPlugin.

        Parameter 'orig' is the MultiSBMLDocumentPlugin instance to copy.

        """
        this = _libsbml.new_MultiSBMLDocumentPlugin(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(MultiSBMLDocumentPlugin self) -> MultiSBMLDocumentPlugin


        Creates and returns a deep copy of this MultiSBMLDocumentPlugin
        object.

        Returns a (deep) copy of this MultiSBMLDocumentPlugin object.

        """
        return _libsbml.MultiSBMLDocumentPlugin_clone(self)

    __swig_destroy__ = _libsbml.delete_MultiSBMLDocumentPlugin
    __del__ = lambda self: None

    def isCompFlatteningImplemented(self):
        """
        isCompFlatteningImplemented(MultiSBMLDocumentPlugin self) -> bool


        Internal implementation method.

        """
        return _libsbml.MultiSBMLDocumentPlugin_isCompFlatteningImplemented(self)


    def checkConsistency(self):
        """
        checkConsistency(MultiSBMLDocumentPlugin self) -> unsigned int


        Internal implementation method.

        """
        return _libsbml.MultiSBMLDocumentPlugin_checkConsistency(self)

MultiSBMLDocumentPlugin_swigregister = _libsbml.MultiSBMLDocumentPlugin_swigregister
MultiSBMLDocumentPlugin_swigregister(MultiSBMLDocumentPlugin)

class MultiModelPlugin(SBasePlugin):
    """

    [SBML 'multi' package]  Extension of Model.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    The MultiModelPlugin object is used to extend the standard SBML Model
    object to allow a ListOfSpeciesTypes child.

    """

    __swig_setmethods__ = {}
    for _s in [SBasePlugin]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MultiModelPlugin, name, value)
    __swig_getmethods__ = {}
    for _s in [SBasePlugin]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, MultiModelPlugin, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(MultiModelPlugin self, string uri, string prefix, MultiPkgNamespaces multins) -> MultiModelPlugin
        __init__(MultiModelPlugin self, MultiModelPlugin orig) -> MultiModelPlugin


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            MultiModelPlugin(MultiModelPlugin orig)

        Copy constructor for MultiModelPlugin.

        Parameter 'orig' is the MultiModelPlugin instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            MultiModelPlugin(string uri, string prefix,
        MultiPkgNamespaces multins)

        Creates a new MultiModelPlugin object using the given parameters.

        In the XML representation of an SBML document, XML namespaces are
        used to identify the origin of each XML construct used.  XML
        namespaces are identified by their unique resource identifiers (URIs).
        The core SBML specifications stipulate the namespaces that must be
        used for core SBML constructs; for example, all XML elements that
        belong to SBML Level 3 Version 1 Core must be placed in the XML
        namespace identified by the URI
        'http://www.sbml.org/sbml/level3/version1/core'.  Individual SBML
        Level 3 packages define their own XML namespaces; for example, all
        elements belonging to the SBML Level 3 Layout Version 1 package must
        be placed in the XML namespace
        'http://www.sbml.org/sbml/level3/version1/layout/version1/'.

        The SBMLNamespaces object encapsulates SBML Level/Version/namespaces
        information.  It is used to communicate the SBML Level, Version, and
        (in Level 3) packages used in addition to SBML Level 3 Core.  A common
        approach to using libSBML's SBMLNamespaces facilities is to create an
        SBMLNamespaces object somewhere in a program once, then hand that
        object as needed to object constructors that accept SBMLNamespaces as
        arguments.

        Parameter 'uri' is the URI of the SBML Level 3 package implemented by
        this libSBML package extension.

        Parameter 'prefix' is the XML namespace prefix being used for the
        package.

        Parameter 'multins' is the namespaces object for the package.

        """
        this = _libsbml.new_MultiModelPlugin(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(MultiModelPlugin self) -> MultiModelPlugin


        Creates and returns a deep copy of this MultiModelPlugin object.

        Returns a (deep) copy of this MultiModelPlugin object.

        """
        return _libsbml.MultiModelPlugin_clone(self)

    __swig_destroy__ = _libsbml.delete_MultiModelPlugin
    __del__ = lambda self: None

    def createObject(self, stream):
        """
        createObject(MultiModelPlugin self, XMLInputStream stream) -> SBase


        Internal implementation method.

        """
        return _libsbml.MultiModelPlugin_createObject(self, stream)


    def hasRequiredElements(self):
        """
        hasRequiredElements(MultiModelPlugin self) -> bool


        Returns 'True' if this object has all the required elements.

        Returns 'True' if this object has all the elements required by the
        package specification; otherwise, 'False' will be returned.

        """
        return _libsbml.MultiModelPlugin_hasRequiredElements(self)


    def getListOfMultiSpeciesTypes(self, *args):
        """
        getListOfMultiSpeciesTypes(MultiModelPlugin self) -> ListOfMultiSpeciesTypes
        getListOfMultiSpeciesTypes(MultiModelPlugin self) -> ListOfMultiSpeciesTypes


        Returns the ListOfMultiSpeciesTypes in this plugin object.

        Returns ListOfMultiSpeciesTypes object in this plugin object.

        """
        return _libsbml.MultiModelPlugin_getListOfMultiSpeciesTypes(self, *args)


    def getMultiSpeciesType(self, *args):
        """
        getMultiSpeciesType(MultiModelPlugin self, unsigned int n) -> MultiSpeciesType
        getMultiSpeciesType(MultiModelPlugin self, unsigned int n) -> MultiSpeciesType
        getMultiSpeciesType(MultiModelPlugin self, string sid) -> MultiSpeciesType
        getMultiSpeciesType(MultiModelPlugin self, string sid) -> MultiSpeciesType


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getMultiSpeciesType(long n)

        Returns the MultiSpeciesType object that belongs to the given index.
        If the  index is invalid, None is returned.

        Parameter 'n' is the index number of the MultiSpeciesType to get

        Returns the nth MultiSpeciesType in the ListOfMultiSpeciesTypes If the
        index 'n' is invalid, 'None' is returned.

        ______________________________________________________________________
        Method variant with the following signature:

            getMultiSpeciesType(string sid)

        Returns the MultiSpeciesType object based on its identifier.

        Parameter 'sid' is a string representing the id of the
        MultiSpeciesType to get

        Returns MultiSpeciesType in the ListOfMultiSpeciesTypes with the given
        id or 'None' if no such MultiSpeciesType exists.

        """
        return _libsbml.MultiModelPlugin_getMultiSpeciesType(self, *args)


    def addMultiSpeciesType(self, multiSpeciesType):
        """
        addMultiSpeciesType(MultiModelPlugin self, MultiSpeciesType multiSpeciesType) -> int


        Adds a copy of the given MultiSpeciesType to the
        ListOfMultiSpeciesTypes in this plugin object.

        Parameter 'multiSpeciesType' is the multiSpeciesType to be added.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.MultiModelPlugin_addMultiSpeciesType(self, multiSpeciesType)


    def createMultiSpeciesType(self):
        """
        createMultiSpeciesType(MultiModelPlugin self) -> MultiSpeciesType


        Creates a new MultiSpeciesType object and adds it to the
        ListOfMultiSpeciesTypes in this plugin object.

        Returns the newly created MultiSpeciesType object.

        """
        return _libsbml.MultiModelPlugin_createMultiSpeciesType(self)


    def createBindingSiteSpeciesType(self):
        """
        createBindingSiteSpeciesType(MultiModelPlugin self) -> BindingSiteSpeciesType


        Creates a new BindingSiteSpeciesType object and adds it to the
        ListOfMultiSpeciesTypes in this plugin object.

        Returns the newly created BindingSiteSpeciesType object.

        """
        return _libsbml.MultiModelPlugin_createBindingSiteSpeciesType(self)


    def removeMultiSpeciesType(self, *args):
        """
        removeMultiSpeciesType(MultiModelPlugin self, unsigned int n) -> MultiSpeciesType
        removeMultiSpeciesType(MultiModelPlugin self, string sid) -> MultiSpeciesType


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeMultiSpeciesType(long n)

        Removes the nth MultiSpeciesType object from this plugin object and
        returns a pointer to it.

        The caller owns the returned object and is responsible for deleting
        it.

        Parameter 'n' is the index of the MultiSpeciesType to remove

        Returns the MultiSpeciesType object removed  or 'None' index was out
        of range.

        ______________________________________________________________________
        Method variant with the following signature:

            removeMultiSpeciesType(string sid)

        Removes the MultiSpeciesType object with the given id from this plugin
        object and returns a pointer to it.

        The caller owns the returned object and is responsible for deleting
        it.

        Parameter 'sid' is a string representing the id of the
        MultiSpeciesType to remove

        Returns the MultiSpeciesType object removed  or 'None' if no such
        MultiSpeciesType exists.

        """
        return _libsbml.MultiModelPlugin_removeMultiSpeciesType(self, *args)


    def getNumMultiSpeciesTypes(self):
        """
        getNumMultiSpeciesTypes(MultiModelPlugin self) -> unsigned int


        Returns the number of MultiSpeciesType objects in this plugin object.

        Returns the number of MultiSpeciesType objects in this plugin object.

        """
        return _libsbml.MultiModelPlugin_getNumMultiSpeciesTypes(self)


    def createIntraSpeciesReaction(self):
        """
        createIntraSpeciesReaction(MultiModelPlugin self) -> IntraSpeciesReaction


        Creates a new IntraSpeciesReaction object and adds it to the
        ListOfReactions.

        Returns the newly created IntraSpeciesReaction object.

        """
        return _libsbml.MultiModelPlugin_createIntraSpeciesReaction(self)


    def connectToParent(self, sbase):
        """
        connectToParent(MultiModelPlugin self, SBase sbase)


        Internal implementation method.

        """
        return _libsbml.MultiModelPlugin_connectToParent(self, sbase)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(MultiModelPlugin self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.MultiModelPlugin_enablePackageInternal(self, pkgURI, pkgPrefix, flag)

MultiModelPlugin_swigregister = _libsbml.MultiModelPlugin_swigregister
MultiModelPlugin_swigregister(MultiModelPlugin)

class MultiCompartmentPlugin(SBasePlugin):
    """

    [SBML 'multi' package]  Extension of Compartment for the 'multi'
    package.

    The MultiCompartmentPlugin object is used to extend the standard SBML
    Compartment base object with an optional 'compartmentType' attribute,
    a required 'isType' Boolean attribute, and a child
    ListOfCompartmentReferences.  The 'isType' attribute flags whether
    this Compartment should be treated as a standard SBML Compartment (if
    'False),' or as a more generic rule-based 'type' of Compartment (if
    'True).'  A compartment 'type' is a template (in the sense of
    prototype) for all Compartment objects referencing it (via
    'compartmentType' attributes). A Species object directly referencing a
    compartment type is not a 'fully defined' species, but rather a
    'template' species.  If the value of the 'isType' attribute is
    'False,' the Compartment object is a 'not-a-type' compartment, and it
    is similar to a SBML core Compartment except it can reference a
    compartment type and can have a ListOfCompartmentReferences child.
    Each child CompartmentReference in the ListOfCompartmentReferences
    defines a subcompartment of the parent Compartment.  The
    'compartmentType' attribute identifies this Compartment as the
    CompartmentType defined elsewhere in the Model.  If the
    'compartmentType' attribute is set, the 'isType' attribute must be
    'True.'

    """

    __swig_setmethods__ = {}
    for _s in [SBasePlugin]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MultiCompartmentPlugin, name, value)
    __swig_getmethods__ = {}
    for _s in [SBasePlugin]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, MultiCompartmentPlugin, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(MultiCompartmentPlugin self, string uri, string prefix, MultiPkgNamespaces multins) -> MultiCompartmentPlugin
        __init__(MultiCompartmentPlugin self, MultiCompartmentPlugin orig) -> MultiCompartmentPlugin


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            MultiCompartmentPlugin(string uri, string prefix,
        MultiPkgNamespaces multins)

        Creates a new MultiCompartmentPlugin object.

        In the XML representation of an SBML document, XML namespaces are
        used to identify the origin of each XML construct used.  XML
        namespaces are identified by their unique resource identifiers (URIs).
        The core SBML specifications stipulate the namespaces that must be
        used for core SBML constructs; for example, all XML elements that
        belong to SBML Level 3 Version 1 Core must be placed in the XML
        namespace identified by the URI
        'http://www.sbml.org/sbml/level3/version1/core'.  Individual SBML
        Level 3 packages define their own XML namespaces; for example, all
        elements belonging to the SBML Level 3 Layout Version 1 package must
        be placed in the XML namespace
        'http://www.sbml.org/sbml/level3/version1/layout/version1/'.

        The SBMLNamespaces object encapsulates SBML Level/Version/namespaces
        information.  It is used to communicate the SBML Level, Version, and
        (in Level 3) packages used in addition to SBML Level 3 Core.  A common
        approach to using libSBML's SBMLNamespaces facilities is to create an
        SBMLNamespaces object somewhere in a program once, then hand that
        object as needed to object constructors that accept SBMLNamespaces as
        arguments.

        Parameter 'uri' is the URI of the SBML Level 3 package implemented by
        this libSBML package extension.

        Parameter 'prefix' is the XML namespace prefix being used for the
        package.

        Parameter 'multins' is the namespaces object for the package.

        ______________________________________________________________________
        Method variant with the following signature:

            MultiCompartmentPlugin(MultiCompartmentPlugin orig)

        Copy constructor for MultiCompartmentPlugin.

        Parameter 'orig' is the MultiCompartmentPlugin instance to copy.

        """
        this = _libsbml.new_MultiCompartmentPlugin(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(MultiCompartmentPlugin self) -> MultiCompartmentPlugin


        Creates and returns a deep copy of this MultiCompartmentPlugin object.

        Returns a (deep) copy of this MultiCompartmentPlugin object.

        """
        return _libsbml.MultiCompartmentPlugin_clone(self)

    __swig_destroy__ = _libsbml.delete_MultiCompartmentPlugin
    __del__ = lambda self: None

    def createObject(self, stream):
        """
        createObject(MultiCompartmentPlugin self, XMLInputStream stream) -> SBase


        Internal implementation method.

        """
        return _libsbml.MultiCompartmentPlugin_createObject(self, stream)


    def hasRequiredElements(self):
        """
        hasRequiredElements(MultiCompartmentPlugin self) -> bool


        Returns 'True' if this object has all the required elements.

        Returns 'True' if this object has all the elements required by the
        package specification; otherwise, 'False' will be returned.

        """
        return _libsbml.MultiCompartmentPlugin_hasRequiredElements(self)


    def getCompartmentType(self):
        """
        getCompartmentType(MultiCompartmentPlugin self) -> string


        Returns the value of the 'compartmentType' attribute of this
        compartment.

        Returns the 'compartmentType' attribute value.

        """
        return _libsbml.MultiCompartmentPlugin_getCompartmentType(self)


    def isSetCompartmentType(self):
        """
        isSetCompartmentType(MultiCompartmentPlugin self) -> bool


        Returns 'True' if this compartment's 'compartmentType' attribute has
        been set.

        Returns 'True' if the 'compartmentType' attribute has been set;
        otherwise, 'False' is returned.

        """
        return _libsbml.MultiCompartmentPlugin_isSetCompartmentType(self)


    def setCompartmentType(self, compartmentType):
        """
        setCompartmentType(MultiCompartmentPlugin self, string compartmentType) -> int


        Sets the value of the 'compartmentType' attribute on this compartment.

        Parameter 'compartmentType' is the new value for the attribute.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.MultiCompartmentPlugin_setCompartmentType(self, compartmentType)


    def unsetCompartmentType(self):
        """
        unsetCompartmentType(MultiCompartmentPlugin self) -> int


        Unsets the value of the 'compartmentType' attribute.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.MultiCompartmentPlugin_unsetCompartmentType(self)


    def getIsType(self):
        """
        getIsType(MultiCompartmentPlugin self) -> bool


        Returns the value of the 'isType' attribute.

        Returns the value of the 'isType' attribute.

        """
        return _libsbml.MultiCompartmentPlugin_getIsType(self)


    def isSetIsType(self):
        """
        isSetIsType(MultiCompartmentPlugin self) -> bool


        Returns 'True' if this compartment's 'isType' attribute has been set.

        Returns 'True' if the 'isType' attribute has been set; otherwise,
        'False' is returned.

        """
        return _libsbml.MultiCompartmentPlugin_isSetIsType(self)


    def setIsType(self, isType):
        """
        setIsType(MultiCompartmentPlugin self, bool isType) -> int


        Sets the value of the 'isType' attribute.

        Parameter 'isType' is the new value of the attribute.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.MultiCompartmentPlugin_setIsType(self, isType)


    def unsetIsType(self):
        """
        unsetIsType(MultiCompartmentPlugin self) -> int


        Unsets the value of the 'isType' attribute.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.MultiCompartmentPlugin_unsetIsType(self)


    def getListOfCompartmentReferences(self, *args):
        """
        getListOfCompartmentReferences(MultiCompartmentPlugin self) -> ListOfCompartmentReferences
        getListOfCompartmentReferences(MultiCompartmentPlugin self) -> ListOfCompartmentReferences


        Returns the ListOfCompartmentReferences object.

        Returns the ListOfCompartmentReferences object within this 'multi'
        Compartment object.

        """
        return _libsbml.MultiCompartmentPlugin_getListOfCompartmentReferences(self, *args)


    def getCompartmentReference(self, *args):
        """
        getCompartmentReference(MultiCompartmentPlugin self, unsigned int n) -> CompartmentReference
        getCompartmentReference(MultiCompartmentPlugin self, unsigned int n) -> CompartmentReference
        getCompartmentReference(MultiCompartmentPlugin self, string sid) -> CompartmentReference
        getCompartmentReference(MultiCompartmentPlugin self, string sid) -> CompartmentReference


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getCompartmentReference(long n)

        Returns the nth CompartmentReference object from the
        ListOfCompartmentReferences.

        Parameter 'n' is the index number of the CompartmentReference to get.

        Returns the nth CompartmentReference, or 'None' if the index 'n' is
        out of range.

        ______________________________________________________________________
        Method variant with the following signature:

            getCompartmentReference(string sid)

        Returns the CompartmentReference with the given identifier 'sid'.

        Parameter 'sid' is the identifier of the CompartmentReference object
        to get from the ListOfCompartmentReferences.

        Returns the CompartmentReference object with the given identifier in
        the ListOfCompartmentReferences, or 'None' if no such
        CompartmentReference exists.

        """
        return _libsbml.MultiCompartmentPlugin_getCompartmentReference(self, *args)


    def addCompartmentReference(self, compartmentReference):
        """
        addCompartmentReference(MultiCompartmentPlugin self, CompartmentReference compartmentReference) -> int


        Adds a copy of the given CompartmentReference object to the
        ListOfCompartmentReferences.

        Parameter 'compartmentReference' is the CompartmentReference object to
        add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.MultiCompartmentPlugin_addCompartmentReference(self, compartmentReference)


    def createCompartmentReference(self):
        """
        createCompartmentReference(MultiCompartmentPlugin self) -> CompartmentReference


        Creates a new CompartmentReference object and adds it to the
        ListOfCompartmentReferences.

        Returns the newly created CompartmentReference object.

        """
        return _libsbml.MultiCompartmentPlugin_createCompartmentReference(self)


    def removeCompartmentReference(self, *args):
        """
        removeCompartmentReference(MultiCompartmentPlugin self, unsigned int n) -> CompartmentReference
        removeCompartmentReference(MultiCompartmentPlugin self, string sid) -> CompartmentReference


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeCompartmentReference(long n)

        Removes the nth CompartmentReference object from the
        ListOfCompartmentReferences.

        Parameter 'n' is the index of the CompartmentReference to remove.

        Returns the CompartmentReference object removed, or 'None' if the
        given index 'n' is out of range.  Note that the caller owns the
        returned object and is responsible for deleting it.

        ______________________________________________________________________
        Method variant with the following signature:

            removeCompartmentReference(string sid)

        Removes the CompartmentReference object with the given identifier from
        the ListOfCompartmentReferences.

        Parameter 'sid' is the id of the CompartmentReference to remove.

        Returns the CompartmentReference object removed, or 'None' if no such
        CompartmentReference exists.  Note that the caller owns the returned
        object and is responsible for deleting it.

        """
        return _libsbml.MultiCompartmentPlugin_removeCompartmentReference(self, *args)


    def getNumCompartmentReferences(self):
        """
        getNumCompartmentReferences(MultiCompartmentPlugin self) -> unsigned int


        Returns the number of CompartmentReference objects in the
        ListOfCompartmentReferences.

        Returns the number of CompartmentReference objects.

        """
        return _libsbml.MultiCompartmentPlugin_getNumCompartmentReferences(self)


    def connectToParent(self, sbase):
        """
        connectToParent(MultiCompartmentPlugin self, SBase sbase)


        Internal implementation method.

        """
        return _libsbml.MultiCompartmentPlugin_connectToParent(self, sbase)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(MultiCompartmentPlugin self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.MultiCompartmentPlugin_enablePackageInternal(self, pkgURI, pkgPrefix, flag)

MultiCompartmentPlugin_swigregister = _libsbml.MultiCompartmentPlugin_swigregister
MultiCompartmentPlugin_swigregister(MultiCompartmentPlugin)

class MultiSpeciesPlugin(SBasePlugin):
    """

    [SBML 'multi' package]  Extension of Species for the 'multi'
    package.

    The MultiSpeciesPlugin class extends the Species class to have a new
    attribute 'speciesType', and two extra optional
    ListOfOutwardBindingSites and ListOfSpeciesFeatures children. A
    species may have a ListOfOutwardBindingSites child and/or a
    ListOfSpeciesFeatures child only when its speciesType attribute has
    been defined.  The relationship among the elements of a
    ListOfOutwardBindingSites or a ListOfSpeciesFeatures is 'and'.

    """

    __swig_setmethods__ = {}
    for _s in [SBasePlugin]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MultiSpeciesPlugin, name, value)
    __swig_getmethods__ = {}
    for _s in [SBasePlugin]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, MultiSpeciesPlugin, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(MultiSpeciesPlugin self, string uri, string prefix, MultiPkgNamespaces multins) -> MultiSpeciesPlugin
        __init__(MultiSpeciesPlugin self, MultiSpeciesPlugin orig) -> MultiSpeciesPlugin


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            MultiSpeciesPlugin(string uri, string prefix,
        MultiPkgNamespaces multins)

        Creates a new MultiSpeciesPlugin object.

        In the XML representation of an SBML document, XML namespaces are
        used to identify the origin of each XML construct used.  XML
        namespaces are identified by their unique resource identifiers (URIs).
        The core SBML specifications stipulate the namespaces that must be
        used for core SBML constructs; for example, all XML elements that
        belong to SBML Level 3 Version 1 Core must be placed in the XML
        namespace identified by the URI
        'http://www.sbml.org/sbml/level3/version1/core'.  Individual SBML
        Level 3 packages define their own XML namespaces; for example, all
        elements belonging to the SBML Level 3 Layout Version 1 package must
        be placed in the XML namespace
        'http://www.sbml.org/sbml/level3/version1/layout/version1/'.

        The SBMLNamespaces object encapsulates SBML Level/Version/namespaces
        information.  It is used to communicate the SBML Level, Version, and
        (in Level 3) packages used in addition to SBML Level 3 Core.  A common
        approach to using libSBML's SBMLNamespaces facilities is to create an
        SBMLNamespaces object somewhere in a program once, then hand that
        object as needed to object constructors that accept SBMLNamespaces as
        arguments.

        Parameter 'uri' is the URI of the SBML Level 3 package implemented by
        this libSBML package extension.

        Parameter 'prefix' is the XML namespace prefix being used for the
        package.

        Parameter 'multins' is the namespaces object for the package.

        ______________________________________________________________________
        Method variant with the following signature:

            MultiSpeciesPlugin(MultiSpeciesPlugin orig)

        Copy constructor for MultiSpeciesPlugin.

        Parameter 'orig' is the MultiSpeciesPlugin instance to copy.

        """
        this = _libsbml.new_MultiSpeciesPlugin(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(MultiSpeciesPlugin self) -> MultiSpeciesPlugin


        Creates and returns a deep copy of this MultiSpeciesPlugin object.

        Returns a (deep) copy of this MultiSpeciesPlugin object.

        """
        return _libsbml.MultiSpeciesPlugin_clone(self)

    __swig_destroy__ = _libsbml.delete_MultiSpeciesPlugin
    __del__ = lambda self: None

    def createObject(self, stream):
        """
        createObject(MultiSpeciesPlugin self, XMLInputStream stream) -> SBase


        Internal implementation method.

        """
        return _libsbml.MultiSpeciesPlugin_createObject(self, stream)


    def hasRequiredElements(self):
        """
        hasRequiredElements(MultiSpeciesPlugin self) -> bool


        Returns 'True' if this object has all the required elements.

        Returns 'True' if this object has all the elements required by the
        package specification; otherwise, 'False' will be returned.

        """
        return _libsbml.MultiSpeciesPlugin_hasRequiredElements(self)


    def getSpeciesType(self):
        """
        getSpeciesType(MultiSpeciesPlugin self) -> string


        Returns the value of the 'speciesType' attribute of this 'multi'
        Species.

        Returns the value of the 'speciesType' attribute.

        """
        return _libsbml.MultiSpeciesPlugin_getSpeciesType(self)


    def isSetSpeciesType(self):
        """
        isSetSpeciesType(MultiSpeciesPlugin self) -> bool


        Returns 'True' if the 'speciesType' attribute of this 'multi' Species
        has been set.

        Returns 'True' if this SpeciesPlugin's 'speciesType' attribute has
        been set, otherwise 'False' is returned.

        """
        return _libsbml.MultiSpeciesPlugin_isSetSpeciesType(self)


    def setSpeciesType(self, speciesType):
        """
        setSpeciesType(MultiSpeciesPlugin self, string speciesType) -> int


        Sets the value of the 'speciesType' attribute on this 'multi' Species.

        Parameter 'speciesType' is the new value for the attribute.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.MultiSpeciesPlugin_setSpeciesType(self, speciesType)


    def unsetSpeciesType(self):
        """
        unsetSpeciesType(MultiSpeciesPlugin self) -> int


        Unsets the value of the 'speciesType' attribute on this 'multi'
        Species.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.MultiSpeciesPlugin_unsetSpeciesType(self)


    def getListOfOutwardBindingSites(self, *args):
        """
        getListOfOutwardBindingSites(MultiSpeciesPlugin self) -> ListOfOutwardBindingSites
        getListOfOutwardBindingSites(MultiSpeciesPlugin self) -> ListOfOutwardBindingSites


        Returns the ListOfOutwardBindingSites of this 'multi' Species.

        Returns the ListOfOutwardBindingSites object.

        """
        return _libsbml.MultiSpeciesPlugin_getListOfOutwardBindingSites(self, *args)


    def getOutwardBindingSite(self, *args):
        """
        getOutwardBindingSite(MultiSpeciesPlugin self, unsigned int n) -> OutwardBindingSite
        getOutwardBindingSite(MultiSpeciesPlugin self, unsigned int n) -> OutwardBindingSite
        getOutwardBindingSite(MultiSpeciesPlugin self, string sid) -> OutwardBindingSite
        getOutwardBindingSite(MultiSpeciesPlugin self, string sid) -> OutwardBindingSite


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getOutwardBindingSite(long n)

        Returns the nth OutwardBindingSite object.

        Parameter 'n' is the index number of the OutwardBindingSite to get

        Returns the nth OutwardBindingSite in the ListOfOutwardBindingSites.
        If the index is invalid, None is returned.

        ______________________________________________________________________
        Method variant with the following signature:

            getOutwardBindingSite(string sid)

        Returns the OutwardBindingSite object with the given identifier 'sid'.

        Parameter 'sid' is a string representing the id of the
        OutwardBindingSite to get.

        Returns OutwardBindingSite in the ListOfOutwardBindingSites with the
        given id or 'None' if no such OutwardBindingSite exists.

        """
        return _libsbml.MultiSpeciesPlugin_getOutwardBindingSite(self, *args)


    def addOutwardBindingSite(self, outwardBindingSite):
        """
        addOutwardBindingSite(MultiSpeciesPlugin self, OutwardBindingSite outwardBindingSite) -> int


        Adds a copy of the given OutwardBindingSite to the
        ListOfOutwardBindingSites.

        Parameter 'outwardBindingSite' is the outwardBindingSite to be added.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.MultiSpeciesPlugin_addOutwardBindingSite(self, outwardBindingSite)


    def createOutwardBindingSite(self):
        """
        createOutwardBindingSite(MultiSpeciesPlugin self) -> OutwardBindingSite


        Creates a new OutwardBindingSite object and adds it to the
        ListOfOutwardBindingSites.

        Returns the newly created OutwardBindingSite object.

        """
        return _libsbml.MultiSpeciesPlugin_createOutwardBindingSite(self)


    def removeOutwardBindingSite(self, *args):
        """
        removeOutwardBindingSite(MultiSpeciesPlugin self, unsigned int n) -> OutwardBindingSite
        removeOutwardBindingSite(MultiSpeciesPlugin self, string sid) -> OutwardBindingSite


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeOutwardBindingSite(long n)

        Removes the nth OutwardBindingSite object and returns a pointer to it.

        Parameter 'n' is the index of the OutwardBindingSite to remove.

        Returns the OutwardBindingSite object removed or 'None' index was out
        of range.  Note that the caller owns the returned object and is
        responsible for deleting it.

        ______________________________________________________________________
        Method variant with the following signature:

            removeOutwardBindingSite(string sid)

        Removes the OutwardBindingSite object with the given id 'sid' and
        returns a pointer to it.

        Parameter 'sid' is a string representing the id of the
        OutwardBindingSite to remove.

        Returns the OutwardBindingSite object removed or 'None' index was out
        of range.  Note that the caller owns the returned object and is
        responsible for deleting it.

        """
        return _libsbml.MultiSpeciesPlugin_removeOutwardBindingSite(self, *args)


    def getNumOutwardBindingSites(self):
        """
        getNumOutwardBindingSites(MultiSpeciesPlugin self) -> unsigned int


        Returns the number of OutwardBindingSite objects of this 'multi'
        Species.

        Returns the number of OutwardBindingSite objects in this plugin
        object.

        """
        return _libsbml.MultiSpeciesPlugin_getNumOutwardBindingSites(self)


    def getListOfSpeciesFeatures(self, *args):
        """
        getListOfSpeciesFeatures(MultiSpeciesPlugin self) -> ListOfSpeciesFeatures
        getListOfSpeciesFeatures(MultiSpeciesPlugin self) -> ListOfSpeciesFeatures


        Returns the ListOfSpeciesFeatures of this 'multi' Species.

        Returns ListOfSpeciesFeatures object in this plugin object.

        """
        return _libsbml.MultiSpeciesPlugin_getListOfSpeciesFeatures(self, *args)


    def getSpeciesFeature(self, *args):
        """
        getSpeciesFeature(MultiSpeciesPlugin self, unsigned int n) -> SpeciesFeature
        getSpeciesFeature(MultiSpeciesPlugin self, unsigned int n) -> SpeciesFeature
        getSpeciesFeature(MultiSpeciesPlugin self, string sid) -> SpeciesFeature
        getSpeciesFeature(MultiSpeciesPlugin self, string sid) -> SpeciesFeature


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getSpeciesFeature(long n)

        Returns the nth SpeciesFeature object.

        Parameter 'n' is the index number of the SpeciesFeature to get.

        Returns the nth SpeciesFeature in the ListOfSpeciesFeatures.  If the
        index is invalid, None is returned.

        ______________________________________________________________________
        Method variant with the following signature:

            getSpeciesFeature(string sid)

        Returns the SpeciesFeature object with the given identifier 'sid'.

        Parameter 'sid' is a string representing the id of the SpeciesFeature
        to get

        Returns SpeciesFeature in the ListOfSpeciesFeatures with the given id
        'sid', or 'None' if no such SpeciesFeature exists.

        """
        return _libsbml.MultiSpeciesPlugin_getSpeciesFeature(self, *args)


    def addSpeciesFeature(self, speciesFeature):
        """
        addSpeciesFeature(MultiSpeciesPlugin self, SpeciesFeature speciesFeature) -> int


        Adds a copy of the given SpeciesFeature to the ListOfSpeciesFeatures
        of this 'multi' Species.

        Parameter 'speciesFeature' is the SpeciesFeature to be added.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.MultiSpeciesPlugin_addSpeciesFeature(self, speciesFeature)


    def createSpeciesFeature(self):
        """
        createSpeciesFeature(MultiSpeciesPlugin self) -> SpeciesFeature


        Creates a new SpeciesFeature object and adds it to the
        ListOfSpeciesFeatures of this 'multi' Species.

        Returns the newly created SpeciesFeature object.

        """
        return _libsbml.MultiSpeciesPlugin_createSpeciesFeature(self)


    def getSubListOfSpeciesFeatures(self, *args):
        """
        getSubListOfSpeciesFeatures(MultiSpeciesPlugin self, unsigned int n) -> SubListOfSpeciesFeatures
        getSubListOfSpeciesFeatures(MultiSpeciesPlugin self, unsigned int n) -> SubListOfSpeciesFeatures
        getSubListOfSpeciesFeatures(MultiSpeciesPlugin self, string sid) -> SubListOfSpeciesFeatures
        getSubListOfSpeciesFeatures(MultiSpeciesPlugin self, string sid) -> SubListOfSpeciesFeatures


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getSubListOfSpeciesFeatures(long n)

        Returns the nth SubListOfSpeciesFeatures object.

        Parameter 'n' is the index number of the SubListOfSpeciesFeatures to
        get

        Returns the nth SubListOfSpeciesFeatures in the ListOfSpeciesFeatures.
        If the index is invalid, None is returned.

        ______________________________________________________________________
        Method variant with the following signature:

            getSubListOfSpeciesFeatures(string sid)

        Returns the SubListOfSpeciesFeatures object with the given identifier
        'sid'.

        Parameter 'sid' is the id of the SubListOfSpeciesFeatures to get.

        Returns SubListOfSpeciesFeatures in the ListOfSpeciesFeatures with the
        given id 'sid', or 'None' if no such SubListOfSpeciesFeatures exists.

        """
        return _libsbml.MultiSpeciesPlugin_getSubListOfSpeciesFeatures(self, *args)


    def addSubListOfSpeciesFeatures(self, subListOfSpeciesFeatures):
        """
        addSubListOfSpeciesFeatures(MultiSpeciesPlugin self, SubListOfSpeciesFeatures subListOfSpeciesFeatures) -> int


        Adds a copy of the given SubListOfSpeciesFeatures to the
        ListOfSpeciesFeatures.

        Parameter 'subListOfSpeciesFeatures' is the SubListOfSpeciesFeatures
        to be added.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.MultiSpeciesPlugin_addSubListOfSpeciesFeatures(self, subListOfSpeciesFeatures)


    def createSubListOfSpeciesFeatures(self):
        """
        createSubListOfSpeciesFeatures(MultiSpeciesPlugin self) -> SubListOfSpeciesFeatures


        Creates a new SubListOfSpeciesFeatures object and adds it to the
        SubListOfSpeciesFeatures.

        Returns the newly created SubListOfSpeciesFeatures object.

        """
        return _libsbml.MultiSpeciesPlugin_createSubListOfSpeciesFeatures(self)


    def removeSpeciesFeature(self, *args):
        """
        removeSpeciesFeature(MultiSpeciesPlugin self, unsigned int n) -> SpeciesFeature
        removeSpeciesFeature(MultiSpeciesPlugin self, string sid) -> SpeciesFeature


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeSpeciesFeature(long n)

        Removes the nth SpeciesFeature object and returns a pointer to it.

        Parameter 'n' is the index of the SpeciesFeature to remove.

        Returns the SpeciesFeature object removed or 'None' index was out of
        range.  Note that the caller owns the returned object and is
        responsible for deleting it.

        ______________________________________________________________________
        Method variant with the following signature:

            removeSpeciesFeature(string sid)

        Removes the SpeciesFeature object with the given identifier 'sid'.

        Parameter 'sid' is a string representing the id of the SpeciesFeature
        to get.

        Returns the SpeciesFeature object removed or 'None' index was out of
        range.  Note that the caller owns the returned object and is
        responsible for deleting it.

        """
        return _libsbml.MultiSpeciesPlugin_removeSpeciesFeature(self, *args)


    def getNumSpeciesFeatures(self):
        """
        getNumSpeciesFeatures(MultiSpeciesPlugin self) -> unsigned int


        Returns the number of SpeciesFeature objects of this 'multi' Species.

        Returns the number of SpeciesFeature objects in this plugin object.

        """
        return _libsbml.MultiSpeciesPlugin_getNumSpeciesFeatures(self)


    def getNumSubListOfSpeciesFeatures(self):
        """
        getNumSubListOfSpeciesFeatures(MultiSpeciesPlugin self) -> unsigned int


        Returns the number of SubListOfSpeciesFeatures objects of this 'multi'
        Species.

        Returns the number of SubListOfSpeciesFeatures objects in this plugin
        object.

        """
        return _libsbml.MultiSpeciesPlugin_getNumSubListOfSpeciesFeatures(self)


    def connectToParent(self, sbase):
        """
        connectToParent(MultiSpeciesPlugin self, SBase sbase)


        Internal implementation method.

        """
        return _libsbml.MultiSpeciesPlugin_connectToParent(self, sbase)


    def connectToChild(self):
        """
        connectToChild(MultiSpeciesPlugin self)


        Internal implementation method.

        """
        return _libsbml.MultiSpeciesPlugin_connectToChild(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(MultiSpeciesPlugin self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.MultiSpeciesPlugin_enablePackageInternal(self, pkgURI, pkgPrefix, flag)

MultiSpeciesPlugin_swigregister = _libsbml.MultiSpeciesPlugin_swigregister
MultiSpeciesPlugin_swigregister(MultiSpeciesPlugin)

class MultiSimpleSpeciesReferencePlugin(SBasePlugin):
    """

    [SBML 'multi' package]  Extension of SimpleSpeciesReference for the
    'multi' package.

    The MultiSpeciesPlugin class extends the SimpleSpeciesReference class
    with a new optional attribute 'compartmentReference', of type SIdRef,
    that points to a CompartmentReference.  The compartmentReference
    attribute can serve to indicate in which subcompartment the
    SpeciesReference or ModifierSpeciesReference (which inherit from
    SimpleSpeciesReference) is located.

    """

    __swig_setmethods__ = {}
    for _s in [SBasePlugin]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MultiSimpleSpeciesReferencePlugin, name, value)
    __swig_getmethods__ = {}
    for _s in [SBasePlugin]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, MultiSimpleSpeciesReferencePlugin, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(MultiSimpleSpeciesReferencePlugin self, string uri, string prefix, MultiPkgNamespaces multins) -> MultiSimpleSpeciesReferencePlugin
        __init__(MultiSimpleSpeciesReferencePlugin self, MultiSimpleSpeciesReferencePlugin orig) -> MultiSimpleSpeciesReferencePlugin


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            MultiSimpleSpeciesReferencePlugin(MultiSimpleSpeciesReference
        Plugin orig)

        Copy constructor for MultiSimpleSpeciesReferencePlugin.

        Parameter 'orig' is the MultiSimpleSpeciesReferencePlugin instance to
        copy.

        ______________________________________________________________________
        Method variant with the following signature:

            MultiSimpleSpeciesReferencePlugin(string uri, string prefix,
        MultiPkgNamespaces multins)

        Creates a new MultiSimpleSpeciesReferencePlugin object.

        In the XML representation of an SBML document, XML namespaces are
        used to identify the origin of each XML construct used.  XML
        namespaces are identified by their unique resource identifiers (URIs).
        The core SBML specifications stipulate the namespaces that must be
        used for core SBML constructs; for example, all XML elements that
        belong to SBML Level 3 Version 1 Core must be placed in the XML
        namespace identified by the URI
        'http://www.sbml.org/sbml/level3/version1/core'.  Individual SBML
        Level 3 packages define their own XML namespaces; for example, all
        elements belonging to the SBML Level 3 Layout Version 1 package must
        be placed in the XML namespace
        'http://www.sbml.org/sbml/level3/version1/layout/version1/'.

        The SBMLNamespaces object encapsulates SBML Level/Version/namespaces
        information.  It is used to communicate the SBML Level, Version, and
        (in Level 3) packages used in addition to SBML Level 3 Core.  A common
        approach to using libSBML's SBMLNamespaces facilities is to create an
        SBMLNamespaces object somewhere in a program once, then hand that
        object as needed to object constructors that accept SBMLNamespaces as
        arguments.

        Parameter 'uri' is the URI of the SBML Level 3 package implemented by
        this libSBML package extension.

        Parameter 'prefix' is the XML namespace prefix being used for the
        package.

        Parameter 'multins' is the namespaces object for the package.

        """
        this = _libsbml.new_MultiSimpleSpeciesReferencePlugin(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(MultiSimpleSpeciesReferencePlugin self) -> MultiSimpleSpeciesReferencePlugin


        Creates and returns a deep copy of this
        MultiSimpleSpeciesReferencePlugin object.

        Returns a (deep) copy of this MultiSimpleSpeciesReferencePlugin
        object.

        """
        return _libsbml.MultiSimpleSpeciesReferencePlugin_clone(self)

    __swig_destroy__ = _libsbml.delete_MultiSimpleSpeciesReferencePlugin
    __del__ = lambda self: None

    def createObject(self, stream):
        """
        createObject(MultiSimpleSpeciesReferencePlugin self, XMLInputStream stream) -> SBase


        Internal implementation method.

        """
        return _libsbml.MultiSimpleSpeciesReferencePlugin_createObject(self, stream)


    def hasRequiredElements(self):
        """
        hasRequiredElements(MultiSimpleSpeciesReferencePlugin self) -> bool


        Returns 'True' if this object has all the required elements.

        Returns 'True' if this object has all the elements required by the
        package specification; otherwise, 'False' will be returned.

        """
        return _libsbml.MultiSimpleSpeciesReferencePlugin_hasRequiredElements(self)


    def getCompartmentReference(self):
        """
        getCompartmentReference(MultiSimpleSpeciesReferencePlugin self) -> string


        Returns the value of the 'compartmentReference' attribute of this
        SimpleSpeciesReference.

        Returns the value of the 'compartmentReference' attribute of this
        SimpleSpeciesReference, as a string.

        """
        return _libsbml.MultiSimpleSpeciesReferencePlugin_getCompartmentReference(self)


    def isSetCompartmentReference(self):
        """
        isSetCompartmentReference(MultiSimpleSpeciesReferencePlugin self) -> bool


        Returns 'True' if this SimpleSpeciesReference's 'compartmentReference'
        attribute has been set.

        Returns 'True' if this SimpleSpeciesReference's 'compartmentReference'
        attribute has been set; otherwise, 'False' is returned.

        """
        return _libsbml.MultiSimpleSpeciesReferencePlugin_isSetCompartmentReference(self)


    def setCompartmentReference(self, compartmentReference):
        """
        setCompartmentReference(MultiSimpleSpeciesReferencePlugin self, string compartmentReference) -> int


        Sets the value of the 'compartmentReference' attribute of this
        SimpleSpeciesReference.

        Parameter 'compartmentReference' is the new value of the
        'compartmentReference' attribute.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.MultiSimpleSpeciesReferencePlugin_setCompartmentReference(self, compartmentReference)


    def unsetCompartmentReference(self):
        """
        unsetCompartmentReference(MultiSimpleSpeciesReferencePlugin self) -> int


        Unsets the value of the 'compartmentReference' attribute of this
        SimpleSpeciesReference.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.MultiSimpleSpeciesReferencePlugin_unsetCompartmentReference(self)


    def connectToParent(self, sbase):
        """
        connectToParent(MultiSimpleSpeciesReferencePlugin self, SBase sbase)


        Internal implementation method.

        """
        return _libsbml.MultiSimpleSpeciesReferencePlugin_connectToParent(self, sbase)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(MultiSimpleSpeciesReferencePlugin self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.MultiSimpleSpeciesReferencePlugin_enablePackageInternal(self, pkgURI, pkgPrefix, flag)

MultiSimpleSpeciesReferencePlugin_swigregister = _libsbml.MultiSimpleSpeciesReferencePlugin_swigregister
MultiSimpleSpeciesReferencePlugin_swigregister(MultiSimpleSpeciesReferencePlugin)

class MultiSpeciesReferencePlugin(MultiSimpleSpeciesReferencePlugin):
    """

    [SBML 'multi' package]  Extension of SpeciesReference for the
    'multi' package.

    The MultiSpeciesReferencePlugin class inherits from the
    MultiSimpleSpeciesReferencePlugin class, and extends the
    SpeciesReference class to establish component mappings between the
    reactant species and the product species when the mappings cannot be
    inferred from the ids of the SpeciesTypeInstance objects. A
    MultiSpeciesReferencePlugin object defines an optional
    ListOfSpeciesTypeComponentMapInProducts child. Only a reaction product
    can contain the ListOfSpeciesTypeComponentMapInProducts child and it
    is not necessary to store the mappings again in the reactants.

    """

    __swig_setmethods__ = {}
    for _s in [MultiSimpleSpeciesReferencePlugin]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MultiSpeciesReferencePlugin, name, value)
    __swig_getmethods__ = {}
    for _s in [MultiSimpleSpeciesReferencePlugin]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, MultiSpeciesReferencePlugin, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(MultiSpeciesReferencePlugin self, string uri, string prefix, MultiPkgNamespaces multins) -> MultiSpeciesReferencePlugin
        __init__(MultiSpeciesReferencePlugin self, MultiSpeciesReferencePlugin orig) -> MultiSpeciesReferencePlugin


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            MultiSpeciesReferencePlugin(MultiSpeciesReferencePlugin orig)

        Copy constructor for MultiSpeciesReferencePlugin.

        Parameter 'orig' is the MultiSpeciesReferencePlugin instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            MultiSpeciesReferencePlugin(string uri, string prefix,
        MultiPkgNamespaces multins)

        Creates a new MultiSpeciesReferencePlugin object.

        In the XML representation of an SBML document, XML namespaces are
        used to identify the origin of each XML construct used.  XML
        namespaces are identified by their unique resource identifiers (URIs).
        The core SBML specifications stipulate the namespaces that must be
        used for core SBML constructs; for example, all XML elements that
        belong to SBML Level 3 Version 1 Core must be placed in the XML
        namespace identified by the URI
        'http://www.sbml.org/sbml/level3/version1/core'.  Individual SBML
        Level 3 packages define their own XML namespaces; for example, all
        elements belonging to the SBML Level 3 Layout Version 1 package must
        be placed in the XML namespace
        'http://www.sbml.org/sbml/level3/version1/layout/version1/'.

        The SBMLNamespaces object encapsulates SBML Level/Version/namespaces
        information.  It is used to communicate the SBML Level, Version, and
        (in Level 3) packages used in addition to SBML Level 3 Core.  A common
        approach to using libSBML's SBMLNamespaces facilities is to create an
        SBMLNamespaces object somewhere in a program once, then hand that
        object as needed to object constructors that accept SBMLNamespaces as
        arguments.

        Parameter 'uri' is the URI of the SBML Level 3 package implemented by
        this libSBML package extension.

        Parameter 'prefix' is the XML namespace prefix being used for the
        package.

        Parameter 'multins' is the namespaces object for the package.

        """
        this = _libsbml.new_MultiSpeciesReferencePlugin(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(MultiSpeciesReferencePlugin self) -> MultiSpeciesReferencePlugin


        Creates and returns a deep copy of this MultiSpeciesReferencePlugin
        object.

        Returns a (deep) copy of this MultiSpeciesReferencePlugin object.

        """
        return _libsbml.MultiSpeciesReferencePlugin_clone(self)

    __swig_destroy__ = _libsbml.delete_MultiSpeciesReferencePlugin
    __del__ = lambda self: None

    def createObject(self, stream):
        """
        createObject(MultiSpeciesReferencePlugin self, XMLInputStream stream) -> SBase


        Internal implementation method.

        """
        return _libsbml.MultiSpeciesReferencePlugin_createObject(self, stream)


    def hasRequiredElements(self):
        """
        hasRequiredElements(MultiSpeciesReferencePlugin self) -> bool


        Returns 'True' if this object has all the required elements.

        Returns 'True' if this object has all the elements required by the
        package specification; otherwise, 'False' will be returned.

        """
        return _libsbml.MultiSpeciesReferencePlugin_hasRequiredElements(self)


    def getListOfSpeciesTypeComponentMapInProducts(self, *args):
        """
        getListOfSpeciesTypeComponentMapInProducts(MultiSpeciesReferencePlugin self) -> ListOfSpeciesTypeComponentMapInProducts
        getListOfSpeciesTypeComponentMapInProducts(MultiSpeciesReferencePlugin self) -> ListOfSpeciesTypeComponentMapInProducts


        Returns the ListOfSpeciesTypeComponentMapInProducts object.

        Returns ListOfSpeciesTypeComponentMapInProducts object within this
        'multi' SpeciesReference object.

        """
        return _libsbml.MultiSpeciesReferencePlugin_getListOfSpeciesTypeComponentMapInProducts(self, *args)


    def getSpeciesTypeComponentMapInProduct(self, *args):
        """
        getSpeciesTypeComponentMapInProduct(MultiSpeciesReferencePlugin self, unsigned int n) -> SpeciesTypeComponentMapInProduct
        getSpeciesTypeComponentMapInProduct(MultiSpeciesReferencePlugin self, unsigned int n) -> SpeciesTypeComponentMapInProduct
        getSpeciesTypeComponentMapInProduct(MultiSpeciesReferencePlugin self, string sid) -> SpeciesTypeComponentMapInProduct
        getSpeciesTypeComponentMapInProduct(MultiSpeciesReferencePlugin self, string sid) -> SpeciesTypeComponentMapInProduct


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getSpeciesTypeComponentMapInProduct(long n)

        Returns the nth SpeciesTypeComponentMapInProduct object.

        Parameter 'n' is the index number of the
        SpeciesTypeComponentMapInProduct to get.

        Returns the nth SpeciesTypeComponentMapInProduct in the
        ListOfSpeciesTypeComponentMapInProducts. If the index is invalid, None
        is returned.

        ______________________________________________________________________
        Method variant with the following signature:

            getSpeciesTypeComponentMapInProduct(string sid)

        Returns the SpeciesTypeComponentMapInProduct object with the given
        identifier 'sid'.

        Parameter 'sid' is a string representing the id of the
        SpeciesTypeComponentMapInProduct to get.

        Returns the SpeciesTypeComponentMapInProduct object within the
        ListOfSpeciesTypeComponentMapInProducts with the given id, or 'None'
        if no such SpeciesTypeComponentMapInProduct exists.

        """
        return _libsbml.MultiSpeciesReferencePlugin_getSpeciesTypeComponentMapInProduct(self, *args)


    def addSpeciesTypeComponentMapInProduct(self, speciesTypeComponentMapInProduct):
        """
        addSpeciesTypeComponentMapInProduct(MultiSpeciesReferencePlugin self, SpeciesTypeComponentMapInProduct speciesTypeComponentMapInProduct) -> int


        Adds a copy of the given SpeciesTypeComponentMapInProduct to the
        ListOfSpeciesTypeComponentMapInProducts.

        Parameter 'speciesTypeComponentMapInProduct' is the
        speciesTypeComponentMapInProduct to be added.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.MultiSpeciesReferencePlugin_addSpeciesTypeComponentMapInProduct(self, speciesTypeComponentMapInProduct)


    def createSpeciesTypeComponentMapInProduct(self):
        """
        createSpeciesTypeComponentMapInProduct(MultiSpeciesReferencePlugin self) -> SpeciesTypeComponentMapInProduct


        Creates a new SpeciesTypeComponentMapInProduct object and adds it to
        the ListOfSpeciesTypeComponentMapInProducts.

        Returns the newly created SpeciesTypeComponentMapInProduct object.
        Note that the caller owns the returned object and is responsible for
        deleting it.

        """
        return _libsbml.MultiSpeciesReferencePlugin_createSpeciesTypeComponentMapInProduct(self)


    def removeSpeciesTypeComponentMapInProduct(self, *args):
        """
        removeSpeciesTypeComponentMapInProduct(MultiSpeciesReferencePlugin self, unsigned int n) -> SpeciesTypeComponentMapInProduct
        removeSpeciesTypeComponentMapInProduct(MultiSpeciesReferencePlugin self, string sid) -> SpeciesTypeComponentMapInProduct


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeSpeciesTypeComponentMapInProduct(long n)

        Removes the nth SpeciesTypeComponentMapInProduct object and returns a
        pointer to it.

        Parameter 'n' is the index of the SpeciesTypeComponentMapInProduct to
        remove.

        Returns the SpeciesTypeComponentMapInProduct object removed or 'None'
        index was out of range.  Note that the caller owns the returned object
        and is responsible for deleting it.

        ______________________________________________________________________
        Method variant with the following signature:

            removeSpeciesTypeComponentMapInProduct(string sid)

        Removes the SpeciesTypeComponentMapInProduct object with the given id
        and returns a pointer to it.

        Parameter 'sid' is a string representing the id of the
        SpeciesTypeComponentMapInProduct to remove.

        Returns the SpeciesTypeComponentMapInProduct object removed or 'None'
        if no such SpeciesTypeComponentMapInProduct exists.  Note that the
        caller owns the returned object and is responsible for deleting it.

        """
        return _libsbml.MultiSpeciesReferencePlugin_removeSpeciesTypeComponentMapInProduct(self, *args)


    def getNumSpeciesTypeComponentMapInProducts(self):
        """
        getNumSpeciesTypeComponentMapInProducts(MultiSpeciesReferencePlugin self) -> unsigned int


        Returns the number of SpeciesTypeComponentMapInProduct objects.

        Returns the number of SpeciesTypeComponentMapInProduct objects.

        """
        return _libsbml.MultiSpeciesReferencePlugin_getNumSpeciesTypeComponentMapInProducts(self)


    def connectToParent(self, sbase):
        """
        connectToParent(MultiSpeciesReferencePlugin self, SBase sbase)


        Internal implementation method.

        """
        return _libsbml.MultiSpeciesReferencePlugin_connectToParent(self, sbase)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(MultiSpeciesReferencePlugin self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.MultiSpeciesReferencePlugin_enablePackageInternal(self, pkgURI, pkgPrefix, flag)

MultiSpeciesReferencePlugin_swigregister = _libsbml.MultiSpeciesReferencePlugin_swigregister
MultiSpeciesReferencePlugin_swigregister(MultiSpeciesReferencePlugin)

class MultiListOfReactionsPlugin(SBasePlugin):
    """

    [SBML 'multi' package]  Extension of ListOfReactions for the 'multi'
    package.

    The MultiListOfReactionsPlugin class extends the ListOfReactions class
    to allow a ListOfReactions to contain IntraSpeciesReaction objects as
    well as Reaction objects.

    """

    __swig_setmethods__ = {}
    for _s in [SBasePlugin]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MultiListOfReactionsPlugin, name, value)
    __swig_getmethods__ = {}
    for _s in [SBasePlugin]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, MultiListOfReactionsPlugin, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(MultiListOfReactionsPlugin self, string uri, string prefix, MultiPkgNamespaces multins) -> MultiListOfReactionsPlugin
        __init__(MultiListOfReactionsPlugin self, MultiListOfReactionsPlugin orig) -> MultiListOfReactionsPlugin


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            MultiListOfReactionsPlugin(MultiListOfReactionsPlugin orig)

        Copy constructor for MultiListOfReactionsPlugin.

        Parameter 'orig' is the MultiListOfReactionsPlugin instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            MultiListOfReactionsPlugin(string uri, string prefix,
        MultiPkgNamespaces multins)

        Creates a new MultiListOfReactionsPlugin

        In the XML representation of an SBML document, XML namespaces are
        used to identify the origin of each XML construct used.  XML
        namespaces are identified by their unique resource identifiers (URIs).
        The core SBML specifications stipulate the namespaces that must be
        used for core SBML constructs; for example, all XML elements that
        belong to SBML Level 3 Version 1 Core must be placed in the XML
        namespace identified by the URI
        'http://www.sbml.org/sbml/level3/version1/core'.  Individual SBML
        Level 3 packages define their own XML namespaces; for example, all
        elements belonging to the SBML Level 3 Layout Version 1 package must
        be placed in the XML namespace
        'http://www.sbml.org/sbml/level3/version1/layout/version1/'.

        The SBMLNamespaces object encapsulates SBML Level/Version/namespaces
        information.  It is used to communicate the SBML Level, Version, and
        (in Level 3) packages used in addition to SBML Level 3 Core.  A common
        approach to using libSBML's SBMLNamespaces facilities is to create an
        SBMLNamespaces object somewhere in a program once, then hand that
        object as needed to object constructors that accept SBMLNamespaces as
        arguments.

        Parameter 'uri' is the URI of the SBML Level 3 package implemented by
        this libSBML package extension.

        Parameter 'prefix' is the XML namespace prefix being used for the
        package.

        Parameter 'multins' is the namespaces object for the package.

        """
        this = _libsbml.new_MultiListOfReactionsPlugin(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(MultiListOfReactionsPlugin self) -> MultiListOfReactionsPlugin


        Creates and returns a deep copy of this MultiListOfReactionsPlugin
        object.

        Returns a (deep) copy of this MultiListOfReactionsPlugin object.

        """
        return _libsbml.MultiListOfReactionsPlugin_clone(self)

    __swig_destroy__ = _libsbml.delete_MultiListOfReactionsPlugin
    __del__ = lambda self: None

    def createObject(self, stream):
        """
        createObject(MultiListOfReactionsPlugin self, XMLInputStream stream) -> SBase


        Internal implementation method.

        """
        return _libsbml.MultiListOfReactionsPlugin_createObject(self, stream)


    def isValidTypeForList(self, item):
        """
        isValidTypeForList(MultiListOfReactionsPlugin self, SBase item) -> bool


        Internal implementation method.

        """
        return _libsbml.MultiListOfReactionsPlugin_isValidTypeForList(self, item)

MultiListOfReactionsPlugin_swigregister = _libsbml.MultiListOfReactionsPlugin_swigregister
MultiListOfReactionsPlugin_swigregister(MultiListOfReactionsPlugin)

class PossibleSpeciesFeatureValue(SBase):
    """

    [SBML 'multi' package]  Defines one value of a SpeciesFeature.

    The PossibleSpeciesFeatureValue object is a child of a
    SpeciesFeatureType, and defines one value (though its optional
    'numericValue' attribute) which the parent SpeciesFeatureType can
    hold.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PossibleSpeciesFeatureValue, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, PossibleSpeciesFeatureValue, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(PossibleSpeciesFeatureValue self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> PossibleSpeciesFeatureValue
        __init__(PossibleSpeciesFeatureValue self, unsigned int level, unsigned int version) -> PossibleSpeciesFeatureValue
        __init__(PossibleSpeciesFeatureValue self, unsigned int level) -> PossibleSpeciesFeatureValue
        __init__(PossibleSpeciesFeatureValue self) -> PossibleSpeciesFeatureValue
        __init__(PossibleSpeciesFeatureValue self, MultiPkgNamespaces multins) -> PossibleSpeciesFeatureValue
        __init__(PossibleSpeciesFeatureValue self, PossibleSpeciesFeatureValue orig) -> PossibleSpeciesFeatureValue


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            PossibleSpeciesFeatureValue(PossibleSpeciesFeatureValue orig)

        Copy constructor for PossibleSpeciesFeatureValue.

        Parameter 'orig' is the PossibleSpeciesFeatureValue instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            PossibleSpeciesFeatureValue(long level      =
        MultiExtension.getDefaultLevel(), long version    =
        MultiExtension.getDefaultVersion(), long pkgVersion =
        MultiExtension.getDefaultPackageVersion())

        Creates a new PossibleSpeciesFeatureValue object.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            PossibleSpeciesFeatureValue(MultiPkgNamespaces multins)

        Creates a new PossibleSpeciesFeatureValue with the given
        MultiPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'multins' is the MultiPkgNamespaces object

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_PossibleSpeciesFeatureValue(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(PossibleSpeciesFeatureValue self) -> PossibleSpeciesFeatureValue


        Creates and returns a deep copy of this PossibleSpeciesFeatureValue
        object.

        Returns a (deep) copy of this PossibleSpeciesFeatureValue object.

        """
        return _libsbml.PossibleSpeciesFeatureValue_clone(self)

    __swig_destroy__ = _libsbml.delete_PossibleSpeciesFeatureValue
    __del__ = lambda self: None

    def getId(self):
        """
        getId(PossibleSpeciesFeatureValue self) -> string


        Returns the value of the 'id' attribute of this
        PossibleSpeciesFeatureValue.

        Returns the value of the 'id' attribute of this
        PossibleSpeciesFeatureValue as a string.

        """
        return _libsbml.PossibleSpeciesFeatureValue_getId(self)


    def isSetId(self):
        """
        isSetId(PossibleSpeciesFeatureValue self) -> bool


        Returns 'True' if this PossibleSpeciesFeatureValue's 'id' attribute
        has been set.

        Returns 'True' if this PossibleSpeciesFeatureValue's 'id' attribute
        has been set; otherwise, 'False' is returned.

        """
        return _libsbml.PossibleSpeciesFeatureValue_isSetId(self)


    def setId(self, id):
        """
        setId(PossibleSpeciesFeatureValue self, string id) -> int


        Sets the value of the 'id' attribute of this
        PossibleSpeciesFeatureValue.

        Parameter 'id' is string value of the 'id' attribute to be set

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.PossibleSpeciesFeatureValue_setId(self, id)


    def unsetId(self):
        """
        unsetId(PossibleSpeciesFeatureValue self) -> int


        Unsets the value of the 'id' attribute of this
        PossibleSpeciesFeatureValue.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.PossibleSpeciesFeatureValue_unsetId(self)


    def getName(self):
        """
        getName(PossibleSpeciesFeatureValue self) -> string


        Returns the value of the 'name' attribute of this
        PossibleSpeciesFeatureValue.

        Returns the value of the 'name' attribute of this
        PossibleSpeciesFeatureValue as a string.

        """
        return _libsbml.PossibleSpeciesFeatureValue_getName(self)


    def isSetName(self):
        """
        isSetName(PossibleSpeciesFeatureValue self) -> bool


        Returns 'True' if this PossibleSpeciesFeatureValue's 'name' attribute
        has been set.

        Returns 'True' if this PossibleSpeciesFeatureValue's 'name' attribute
        has been set; otherwise, 'False' is returned.

        """
        return _libsbml.PossibleSpeciesFeatureValue_isSetName(self)


    def setName(self, name):
        """
        setName(PossibleSpeciesFeatureValue self, string name) -> int


        Sets the value of the 'name' attribute of this
        PossibleSpeciesFeatureValue.

        Parameter 'name' is the new 'name' attribute value.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.PossibleSpeciesFeatureValue_setName(self, name)


    def unsetName(self):
        """
        unsetName(PossibleSpeciesFeatureValue self) -> int


        Unsets the value of the 'name' attribute of this
        PossibleSpeciesFeatureValue.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.PossibleSpeciesFeatureValue_unsetName(self)


    def getNumericValue(self):
        """
        getNumericValue(PossibleSpeciesFeatureValue self) -> string


        Returns the value of the 'numericValue' attribute of this
        PossibleSpeciesFeatureValue.

        Returns the value of the 'numericValue' attribute of this
        PossibleSpeciesFeatureValue as a string.

        """
        return _libsbml.PossibleSpeciesFeatureValue_getNumericValue(self)


    def isSetNumericValue(self):
        """
        isSetNumericValue(PossibleSpeciesFeatureValue self) -> bool


        Returns 'True' if this PossibleSpeciesFeatureValue's 'numericValue'
        attribute has been set.

        Returns 'True' if this PossibleSpeciesFeatureValue's 'numericValue'
        attribute has been set; otherwise, 'False' is returned.

        """
        return _libsbml.PossibleSpeciesFeatureValue_isSetNumericValue(self)


    def setNumericValue(self, numericValue):
        """
        setNumericValue(PossibleSpeciesFeatureValue self, string numericValue) -> int


        Sets the value of the 'numericValue' attribute of this
        PossibleSpeciesFeatureValue.

        Parameter 'numericValue' is the new 'numericValue' attribute value.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.PossibleSpeciesFeatureValue_setNumericValue(self, numericValue)


    def unsetNumericValue(self):
        """
        unsetNumericValue(PossibleSpeciesFeatureValue self) -> int


        Unsets the value of the 'numericValue' attribute of this
        PossibleSpeciesFeatureValue.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.PossibleSpeciesFeatureValue_unsetNumericValue(self)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(PossibleSpeciesFeatureValue self, string oldid, string newid)


        Renames all the 'SIdRef' attributes on this element, including any
        found in MathML content (if such exists).

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas, comparing the identifiers to the value of
        'oldid'.  If any matches are found, the matching identifiers are
        replaced with 'newid'.  The method does not descend into child
        elements.

        Parameter 'oldid' is the old identifier Parameter 'newid' is the new
        identifier

        """
        return _libsbml.PossibleSpeciesFeatureValue_renameSIdRefs(self, oldid, newid)


    def getElementName(self):
        """
        getElementName(PossibleSpeciesFeatureValue self) -> string


        Returns the XML element name of this object.

        Returns the name of this element, i.e.
        ''possibleSpeciesFeatureValue'.'

        """
        return _libsbml.PossibleSpeciesFeatureValue_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(PossibleSpeciesFeatureValue self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object:
        SBML_MULTI_BINDING_SITE_SPECIES_TYPE.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.PossibleSpeciesFeatureValue_getTypeCode(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(PossibleSpeciesFeatureValue self) -> bool


        Predicate returning 'True' if all the required attributes for this
        PossibleSpeciesFeatureValue object have been set.

        Note: The required attributes for a PossibleSpeciesFeatureValue object
        are:

        * 'id'

        Returns a boolean value indicating whether all the required attributes
        for this object have been defined.

        """
        return _libsbml.PossibleSpeciesFeatureValue_hasRequiredAttributes(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(PossibleSpeciesFeatureValue self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.PossibleSpeciesFeatureValue_enablePackageInternal(self, pkgURI, pkgPrefix, flag)

PossibleSpeciesFeatureValue_swigregister = _libsbml.PossibleSpeciesFeatureValue_swigregister
PossibleSpeciesFeatureValue_swigregister(PossibleSpeciesFeatureValue)

class ListOfPossibleSpeciesFeatureValues(ListOf):
    """

    [SBML 'multi' package]  A list of PossibleSpeciesFeatureValue
    objects.

    The ListOfPossibleSpeciesFeatureValues is a container for
    PossibleSpeciesFeatureValue objects.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    See also PossibleSpeciesFeatureValue.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfPossibleSpeciesFeatureValues, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfPossibleSpeciesFeatureValues, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ListOfPossibleSpeciesFeatureValues self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ListOfPossibleSpeciesFeatureValues
        __init__(ListOfPossibleSpeciesFeatureValues self, unsigned int level, unsigned int version) -> ListOfPossibleSpeciesFeatureValues
        __init__(ListOfPossibleSpeciesFeatureValues self, unsigned int level) -> ListOfPossibleSpeciesFeatureValues
        __init__(ListOfPossibleSpeciesFeatureValues self) -> ListOfPossibleSpeciesFeatureValues
        __init__(ListOfPossibleSpeciesFeatureValues self, MultiPkgNamespaces multins) -> ListOfPossibleSpeciesFeatureValues


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfPossibleSpeciesFeatureValues(long level      =
        MultiExtension.getDefaultLevel(), long version    =
        MultiExtension.getDefaultVersion(), long pkgVersion =
        MultiExtension.getDefaultPackageVersion())

        Creates a new ListOfPossibleSpeciesFeatureValues object.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfPossibleSpeciesFeatureValues(MultiPkgNamespaces
        multins)

        Creates a new ListOfPossibleSpeciesFeatureValues with the given
        MultiPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'multins' is the MultiPkgNamespaces object

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_ListOfPossibleSpeciesFeatureValues(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ListOfPossibleSpeciesFeatureValues self) -> ListOfPossibleSpeciesFeatureValues


        Creates and returns a deep copy of this
        ListOfPossibleSpeciesFeatureValues object.

        Returns a (deep) copy of this ListOfPossibleSpeciesFeatureValues
        object.

        """
        return _libsbml.ListOfPossibleSpeciesFeatureValues_clone(self)


    def get(self, *args):
        """
        get(ListOfPossibleSpeciesFeatureValues self, unsigned int n) -> PossibleSpeciesFeatureValue
        get(ListOfPossibleSpeciesFeatureValues self, unsigned int n) -> PossibleSpeciesFeatureValue
        get(ListOfPossibleSpeciesFeatureValues self, string sid) -> PossibleSpeciesFeatureValue
        get(ListOfPossibleSpeciesFeatureValues self, string sid) -> PossibleSpeciesFeatureValue


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get the nth PossibleSpeciesFeatureValue object from the
        ListOfPossibleSpeciesFeatureValues.

        Parameter 'n' is the index number of the PossibleSpeciesFeatureValue
        to get.

        Returns the nth object, or 'None' if the index 'is' out of range.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get the PossibleSpeciesFeatureValue with the given identifier 'sid'.

        Parameter 'sid' is a string representing the identifier of the
        PossibleSpeciesFeatureValue to get.

        Returns the object with the given id, or 'None' if no such object
        exists.

        See also get()   *, size().

        """
        return _libsbml.ListOfPossibleSpeciesFeatureValues_get(self, *args)


    def remove(self, *args):
        """
        remove(ListOfPossibleSpeciesFeatureValues self, unsigned int n) -> PossibleSpeciesFeatureValue
        remove(ListOfPossibleSpeciesFeatureValues self, string sid) -> PossibleSpeciesFeatureValue


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth PossibleSpeciesFeatureValue object from the
        ListOfPossibleSpeciesFeatureValues.

        Parameter 'n' is the index of the PossibleSpeciesFeatureValue to
        remove.

        Returns the object removed, or 'None' if no such object exists.  Note
        that the caller owns the returned object and is responsible for
        deleting it.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes the PossibleSpeciesFeatureValue with the given identifier
        'sid'.

        Parameter 'sid' is the identifier of the PossibleSpeciesFeatureValue
        to remove.

        Returns the object removed, or 'None' if no such object exists.  Note
        that the caller owns the returned object and is responsible for
        deleting it.

        """
        return _libsbml.ListOfPossibleSpeciesFeatureValues_remove(self, *args)


    def getElementName(self):
        """
        getElementName(ListOfPossibleSpeciesFeatureValues self) -> string


        Returns the XML element name of this object.

        Returns the name of this element, i.e.
        ''listOfPossibleSpeciesFeatureValues'.'

        """
        return _libsbml.ListOfPossibleSpeciesFeatureValues_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(ListOfPossibleSpeciesFeatureValues self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object:
        SBML_MULTI_BINDING_SITE_SPECIES_TYPE.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfPossibleSpeciesFeatureValues_getTypeCode(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfPossibleSpeciesFeatureValues self) -> int


        Returns the libSBML type code for the objects contained in this ListOf
        (i.e., Compartment objects, if the list is non-empty).

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for the objects contained in this ListOf
        instance: SBML_COMPARTMENT (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfPossibleSpeciesFeatureValues_getItemTypeCode(self)

    __swig_destroy__ = _libsbml.delete_ListOfPossibleSpeciesFeatureValues
    __del__ = lambda self: None
ListOfPossibleSpeciesFeatureValues_swigregister = _libsbml.ListOfPossibleSpeciesFeatureValues_swigregister
ListOfPossibleSpeciesFeatureValues_swigregister(ListOfPossibleSpeciesFeatureValues)

class SpeciesFeatureValue(SBase):
    """

    [SBML 'multi' package]  Defines a particular value for a
    SpeciesFeature.

    The SpeciesFeatureValue object is a child of a SpeciesFeature, and
    serves to specify a value for a SpeciesFeature to select from the
    ListOfPossibleSpeciesFeatureValues defined in the SpeciesFeatureType
    referenced by the parent SpeciesFeature.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SpeciesFeatureValue, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SpeciesFeatureValue, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(SpeciesFeatureValue self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> SpeciesFeatureValue
        __init__(SpeciesFeatureValue self, unsigned int level, unsigned int version) -> SpeciesFeatureValue
        __init__(SpeciesFeatureValue self, unsigned int level) -> SpeciesFeatureValue
        __init__(SpeciesFeatureValue self) -> SpeciesFeatureValue
        __init__(SpeciesFeatureValue self, MultiPkgNamespaces multins) -> SpeciesFeatureValue
        __init__(SpeciesFeatureValue self, SpeciesFeatureValue orig) -> SpeciesFeatureValue


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            SpeciesFeatureValue(long level      =
        MultiExtension.getDefaultLevel(), long version    =
        MultiExtension.getDefaultVersion(), long pkgVersion =
        MultiExtension.getDefaultPackageVersion())

        Creates a new SpeciesFeatureValue object.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            SpeciesFeatureValue(SpeciesFeatureValue orig)

        Copy constructor for SpeciesFeatureValue.

        Parameter 'orig' is the SpeciesFeatureValue instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            SpeciesFeatureValue(MultiPkgNamespaces multins)

        Creates a new SpeciesFeatureValue with the given MultiPkgNamespaces
        object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'multins' is the MultiPkgNamespaces object

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_SpeciesFeatureValue(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(SpeciesFeatureValue self) -> SpeciesFeatureValue


        Creates and returns a deep copy of this SpeciesFeatureValue object.

        Returns a (deep) copy of this SpeciesFeatureValue object.

        """
        return _libsbml.SpeciesFeatureValue_clone(self)

    __swig_destroy__ = _libsbml.delete_SpeciesFeatureValue
    __del__ = lambda self: None

    def getValue(self):
        """
        getValue(SpeciesFeatureValue self) -> string


        Returns the value of the 'value' attribute of this
        SpeciesFeatureValue.

        Returns the value of the 'value' attribute of this SpeciesFeatureValue
        as a string.

        """
        return _libsbml.SpeciesFeatureValue_getValue(self)


    def isSetValue(self):
        """
        isSetValue(SpeciesFeatureValue self) -> bool


        Returns 'True' if this SpeciesFeatureValue's 'value' attribute has
        been set.

        Returns 'True' if this SpeciesFeatureValue's 'value' attribute has
        been set; otherwise, 'False' is returned.

        """
        return _libsbml.SpeciesFeatureValue_isSetValue(self)


    def setValue(self, value):
        """
        setValue(SpeciesFeatureValue self, string value) -> int


        Sets the value of the 'value' attribute of this SpeciesFeatureValue.

        Parameter 'value' is string value of the 'value' attribute to be set

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.SpeciesFeatureValue_setValue(self, value)


    def unsetValue(self):
        """
        unsetValue(SpeciesFeatureValue self) -> int


        Unsets the value of the 'value' attribute of this SpeciesFeatureValue.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.SpeciesFeatureValue_unsetValue(self)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(SpeciesFeatureValue self, string oldid, string newid)


        Renames all the 'SIdRef' attributes on this element, including any
        found in MathML content (if such exists).

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas, comparing the identifiers to the value of
        'oldid'.  If any matches are found, the matching identifiers are
        replaced with 'newid'.  The method does not descend into child
        elements.

        Parameter 'oldid' is the old identifier Parameter 'newid' is the new
        identifier

        """
        return _libsbml.SpeciesFeatureValue_renameSIdRefs(self, oldid, newid)


    def getElementName(self):
        """
        getElementName(SpeciesFeatureValue self) -> string


        Returns the XML element name of this object.

        Returns the name of this element, i.e. ''speciesFeatureValue'.'

        """
        return _libsbml.SpeciesFeatureValue_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(SpeciesFeatureValue self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object:
        SBML_MULTI_BINDING_SITE_SPECIES_TYPE.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.SpeciesFeatureValue_getTypeCode(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(SpeciesFeatureValue self) -> bool


        Predicate returning 'True' if all the required attributes for this
        SpeciesFeatureValue object have been set.

        Note: The required attributes for a SpeciesFeatureValue object are:

        * 'value'

        Returns a boolean value indicating whether all the required attributes
        for this object have been defined.

        """
        return _libsbml.SpeciesFeatureValue_hasRequiredAttributes(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(SpeciesFeatureValue self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.SpeciesFeatureValue_enablePackageInternal(self, pkgURI, pkgPrefix, flag)

SpeciesFeatureValue_swigregister = _libsbml.SpeciesFeatureValue_swigregister
SpeciesFeatureValue_swigregister(SpeciesFeatureValue)

class ListOfSpeciesFeatureValues(ListOf):
    """

    [SBML 'multi' package]  A list of SpeciesFeatureValue objects.

    The ListOfSpeciesFeatureValues is a container for SpeciesFeatureValue
    objects.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    See also SpeciesFeatureValue.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfSpeciesFeatureValues, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfSpeciesFeatureValues, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ListOfSpeciesFeatureValues self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ListOfSpeciesFeatureValues
        __init__(ListOfSpeciesFeatureValues self, unsigned int level, unsigned int version) -> ListOfSpeciesFeatureValues
        __init__(ListOfSpeciesFeatureValues self, unsigned int level) -> ListOfSpeciesFeatureValues
        __init__(ListOfSpeciesFeatureValues self) -> ListOfSpeciesFeatureValues
        __init__(ListOfSpeciesFeatureValues self, MultiPkgNamespaces multins) -> ListOfSpeciesFeatureValues


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfSpeciesFeatureValues(long level      =
        MultiExtension.getDefaultLevel(), long version    =
        MultiExtension.getDefaultVersion(), long pkgVersion =
        MultiExtension.getDefaultPackageVersion())

        Creates a new ListOfSpeciesFeatureValues object.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfSpeciesFeatureValues(MultiPkgNamespaces multins)

        Creates a new ListOfSpeciesFeatureValues with the given
        MultiPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'multins' is the MultiPkgNamespaces object

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_ListOfSpeciesFeatureValues(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ListOfSpeciesFeatureValues self) -> ListOfSpeciesFeatureValues


        Creates and returns a deep copy of this ListOfSpeciesFeatureValues
        object.

        Returns a (deep) copy of this ListOfSpeciesFeatureValues object.

        """
        return _libsbml.ListOfSpeciesFeatureValues_clone(self)


    def get(self, *args):
        """
        get(ListOfSpeciesFeatureValues self, unsigned int n) -> SpeciesFeatureValue
        get(ListOfSpeciesFeatureValues self, unsigned int n) -> SpeciesFeatureValue
        get(ListOfSpeciesFeatureValues self, string sid) -> SpeciesFeatureValue
        get(ListOfSpeciesFeatureValues self, string sid) -> SpeciesFeatureValue


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get the nth SpeciesFeatureValue object from the
        ListOfSpeciesFeatureValues.

        Parameter 'n' is the index number of the SpeciesFeatureValue to get.

        Returns the nth object, or 'None' if the index 'is' out of range.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get the SpeciesFeatureValue object with the given identifier 'sid'.

        Parameter 'sid' is a string representing the identifier of the
        SpeciesFeatureValue to get.

        Returns the object with the given id, or 'None' if no such object
        exists.

        See also get(), size().

        """
        return _libsbml.ListOfSpeciesFeatureValues_get(self, *args)


    def remove(self, *args):
        """
        remove(ListOfSpeciesFeatureValues self, unsigned int n) -> SpeciesFeatureValue
        remove(ListOfSpeciesFeatureValues self, string sid) -> SpeciesFeatureValue


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth SpeciesFeatureValue object from this
        ListOfSpeciesFeatureValues. Parameter 'n' is the index of the
        SpeciesFeatureValue to remove.

        Returns the object removed, or 'None' if no such object exists.  Note
        that the caller owns the returned object and is responsible for
        deleting it.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes the SpeciesFeatureValue object with the given identifier
        'sid'.

        Parameter 'sid' is the identifier of the SpeciesFeatureValue to
        remove.

        Returns the object removed, or 'None' if no such object exists.  Note
        that the caller owns the returned object and is responsible for
        deleting it.

        """
        return _libsbml.ListOfSpeciesFeatureValues_remove(self, *args)


    def getElementName(self):
        """
        getElementName(ListOfSpeciesFeatureValues self) -> string


        Returns the XML element name of this object.

        Returns the name of this element, i.e. ''listOfSpeciesFeatureValues'.'

        """
        return _libsbml.ListOfSpeciesFeatureValues_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(ListOfSpeciesFeatureValues self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object:
        SBML_MULTI_BINDING_SITE_SPECIES_TYPE.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfSpeciesFeatureValues_getTypeCode(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfSpeciesFeatureValues self) -> int


        Returns the libSBML type code for the objects contained in this ListOf
        (i.e., Compartment objects, if the list is non-empty).

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for the objects contained in this ListOf
        instance: SBML_COMPARTMENT (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfSpeciesFeatureValues_getItemTypeCode(self)

    __swig_destroy__ = _libsbml.delete_ListOfSpeciesFeatureValues
    __del__ = lambda self: None
ListOfSpeciesFeatureValues_swigregister = _libsbml.ListOfSpeciesFeatureValues_swigregister
ListOfSpeciesFeatureValues_swigregister(ListOfSpeciesFeatureValues)

class CompartmentReference(SBase):
    """

    [SBML 'multi' package]  Child of a Compartment that references a
    different Compartment.

    A CompartmentReference object is a child of an extended Compartment
    (via the MultiCompartmentPlugin), and provides a way for that
    Compartment to reference another Compartment, and indicates that the
    referenced Compartment is a sub-compartment in a composite parent
    compartment. Compartments may be arbitrarily nested in this way, but
    this nesting cannot be circular.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CompartmentReference, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CompartmentReference, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(CompartmentReference self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> CompartmentReference
        __init__(CompartmentReference self, unsigned int level, unsigned int version) -> CompartmentReference
        __init__(CompartmentReference self, unsigned int level) -> CompartmentReference
        __init__(CompartmentReference self) -> CompartmentReference
        __init__(CompartmentReference self, MultiPkgNamespaces multins) -> CompartmentReference
        __init__(CompartmentReference self, CompartmentReference orig) -> CompartmentReference


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            CompartmentReference(CompartmentReference orig)

        Copy constructor for CompartmentReference.

        Parameter 'orig' is the CompartmentReference instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            CompartmentReference(long level      =
        MultiExtension.getDefaultLevel(), long version    =
        MultiExtension.getDefaultVersion(), long pkgVersion =
        MultiExtension.getDefaultPackageVersion())

        Creates a new CompartmentReference.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            CompartmentReference(MultiPkgNamespaces multins)

        Creates a new CompartmentReference with the given MultiPkgNamespaces
        object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'multins' is the MultiPkgNamespaces object

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_CompartmentReference(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(CompartmentReference self) -> CompartmentReference


        Creates and returns a deep copy of this CompartmentReference object.

        Returns a (deep) copy of this CompartmentReference object.

        """
        return _libsbml.CompartmentReference_clone(self)

    __swig_destroy__ = _libsbml.delete_CompartmentReference
    __del__ = lambda self: None

    def getId(self):
        """
        getId(CompartmentReference self) -> string


        Returns the value of the 'id' attribute of this CompartmentReference.

        Returns the value of the 'id' attribute of this CompartmentReference
        as a string.

        """
        return _libsbml.CompartmentReference_getId(self)


    def isSetId(self):
        """
        isSetId(CompartmentReference self) -> bool


        Returns 'True' if this CompartmentReference's 'id' attribute has been
        set.

        Returns 'True' if this CompartmentReference's 'id' attribute has been
        set; otherwise, 'False' is returned.

        """
        return _libsbml.CompartmentReference_isSetId(self)


    def setId(self, id):
        """
        setId(CompartmentReference self, string id) -> int


        Sets the value of the 'id' attribute of this CompartmentReference.

        Parameter 'id' is string value of the 'id' attribute to be set

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.CompartmentReference_setId(self, id)


    def unsetId(self):
        """
        unsetId(CompartmentReference self) -> int


        Unsets the value of the 'id' attribute of this CompartmentReference.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.CompartmentReference_unsetId(self)


    def getName(self):
        """
        getName(CompartmentReference self) -> string


        Returns the value of the 'name' attribute of this
        CompartmentReference.

        Returns the value of the 'name' attribute of this CompartmentReference
        as a string.

        """
        return _libsbml.CompartmentReference_getName(self)


    def isSetName(self):
        """
        isSetName(CompartmentReference self) -> bool


        Returns 'True' if this CompartmentReference's 'name' attribute has
        been set.

        Returns 'True' if this CompartmentReference's 'name' attribute has
        been set; otherwise, 'False' is returned.

        """
        return _libsbml.CompartmentReference_isSetName(self)


    def setName(self, name):
        """
        setName(CompartmentReference self, string name) -> int


        Sets the value of the 'name' attribute of this CompartmentReference.

        Parameter 'name' is string value of the 'name' attribute to be set

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.CompartmentReference_setName(self, name)


    def unsetName(self):
        """
        unsetName(CompartmentReference self) -> int


        Unsets the value of the 'name' attribute of this CompartmentReference.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.CompartmentReference_unsetName(self)


    def getCompartment(self):
        """
        getCompartment(CompartmentReference self) -> string


        Returns the value of the 'compartment' attribute of this
        CompartmentReference.

        Returns the value of the 'compartment' attribute of this
        CompartmentReference as a string.

        """
        return _libsbml.CompartmentReference_getCompartment(self)


    def isSetCompartment(self):
        """
        isSetCompartment(CompartmentReference self) -> bool


        Returns 'True' if this CompartmentReference's 'compartment' attribute
        has been set.

        Returns 'True' if this CompartmentReference's 'compartment' attribute
        has been set; otherwise, 'False' is returned.

        """
        return _libsbml.CompartmentReference_isSetCompartment(self)


    def setCompartment(self, compartment):
        """
        setCompartment(CompartmentReference self, string compartment) -> int


        Sets the value of the 'compartment' attribute of this
        CompartmentReference.

        Parameter 'compartment' is the new attribute value.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.CompartmentReference_setCompartment(self, compartment)


    def unsetCompartment(self):
        """
        unsetCompartment(CompartmentReference self) -> int


        Unsets the value of the 'compartment' attribute of this
        CompartmentReference.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.CompartmentReference_unsetCompartment(self)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(CompartmentReference self, string oldid, string newid)


        Renames all the 'SIdRef' attributes on this element, including any
        found in MathML content (if such exists).

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas, comparing the identifiers to the value of
        'oldid'.  If any matches are found, the matching identifiers are
        replaced with 'newid'.  The method does not descend into child
        elements.

        Parameter 'oldid' is the old identifier Parameter 'newid' is the new
        identifier

        """
        return _libsbml.CompartmentReference_renameSIdRefs(self, oldid, newid)


    def getElementName(self):
        """
        getElementName(CompartmentReference self) -> string


        Returns the XML element name of this object.

        Returns the name of this element, i.e. ''compartmentReference'.'

        """
        return _libsbml.CompartmentReference_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(CompartmentReference self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object:
        SBML_MULTI_BINDING_SITE_SPECIES_TYPE.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.CompartmentReference_getTypeCode(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(CompartmentReference self) -> bool


        Returns 'True' if all the required attributes for this
        CompartmentReference object have been set.

        Returns a boolean value indicating whether all the required attributes
        for this object have been defined.

        """
        return _libsbml.CompartmentReference_hasRequiredAttributes(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(CompartmentReference self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.CompartmentReference_enablePackageInternal(self, pkgURI, pkgPrefix, flag)

CompartmentReference_swigregister = _libsbml.CompartmentReference_swigregister
CompartmentReference_swigregister(CompartmentReference)

class ListOfCompartmentReferences(ListOf):
    """

    [SBML 'multi' package]  A list of CompartmentReference objects.

    The ListOfCompartmentReferences is a container for
    CompartmentReference objects.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    See also CompartmentReference.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfCompartmentReferences, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfCompartmentReferences, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ListOfCompartmentReferences self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ListOfCompartmentReferences
        __init__(ListOfCompartmentReferences self, unsigned int level, unsigned int version) -> ListOfCompartmentReferences
        __init__(ListOfCompartmentReferences self, unsigned int level) -> ListOfCompartmentReferences
        __init__(ListOfCompartmentReferences self) -> ListOfCompartmentReferences
        __init__(ListOfCompartmentReferences self, MultiPkgNamespaces multins) -> ListOfCompartmentReferences


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfCompartmentReferences(long level      =
        MultiExtension.getDefaultLevel(), long version    =
        MultiExtension.getDefaultVersion(), long pkgVersion =
        MultiExtension.getDefaultPackageVersion())

        Creates a new ListOfCompartmentReferences with the given level,
        version, and package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        ListOfCompartmentReferences

        Parameter 'version' is a long integer, the SBML Version to assign to
        this ListOfCompartmentReferences

        Parameter 'pkgVersion' is a long integer, the SBML Multi Version to
        assign to this ListOfCompartmentReferences

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfCompartmentReferences(MultiPkgNamespaces multins)

        Creates a new ListOfCompartmentReferences with the given
        MultiPkgNamespaces object.

        Parameter 'multins' is the MultiPkgNamespaces object

        """
        this = _libsbml.new_ListOfCompartmentReferences(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ListOfCompartmentReferences self) -> ListOfCompartmentReferences


        Creates and returns a deep copy of this ListOfCompartmentReferences
        object.

        Returns a (deep) copy of this ListOfCompartmentReferences object.

        """
        return _libsbml.ListOfCompartmentReferences_clone(self)


    def get(self, *args):
        """
        get(ListOfCompartmentReferences self, unsigned int n) -> CompartmentReference
        get(ListOfCompartmentReferences self, unsigned int n) -> CompartmentReference
        get(ListOfCompartmentReferences self, string sid) -> CompartmentReference
        get(ListOfCompartmentReferences self, string sid) -> CompartmentReference


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a CompartmentReference from the ListOfCompartmentReferences.

        Parameter 'n' is the index number of the CompartmentReference to get.

        Returns the nth CompartmentReference in this
        ListOfCompartmentReferences. If the index 'n' is invalid, 'None' is
        returned.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a CompartmentReference from the ListOfCompartmentReferences based
        on its identifier.

        Parameter 'sid' is a string representing the identifier of the
        CompartmentReference to get.

        Returns CompartmentReference in this ListOfCompartmentReferences with
        the given id or 'None' if no such CompartmentReference exists.

        See also get()   *, size().

        """
        return _libsbml.ListOfCompartmentReferences_get(self, *args)


    def remove(self, *args):
        """
        remove(ListOfCompartmentReferences self, unsigned int n) -> CompartmentReference
        remove(ListOfCompartmentReferences self, string sid) -> CompartmentReference


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth CompartmentReference from this
        ListOfCompartmentReferences and returns a pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the CompartmentReference to remove.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes the CompartmentReference from this ListOfCompartmentReferences
        with the given identifier and returns a pointer to it.

        The caller owns the returned item and is responsible for deleting it.
        If none of the items in this list have the identifier 'sid', then
        'None' is returned.

        Parameter 'sid' is the identifier of the CompartmentReference to
        remove.

        Returns the CompartmentReference removed. As mentioned above, the
        caller owns the returned item.

        """
        return _libsbml.ListOfCompartmentReferences_remove(self, *args)


    def getElementName(self):
        """
        getElementName(ListOfCompartmentReferences self) -> string


        Returns the XML element name of this object, which for
        ListOfCompartmentReferences, is always
        ''listOfCompartmentReferences'.'

        Returns the name of this element, i.e.
        ''listOfCompartmentReferences'.'

        """
        return _libsbml.ListOfCompartmentReferences_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(ListOfCompartmentReferences self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are known as SBML type codes.  In the Python language interface
        for libSBML, the type codes are defined as static integer constants in
        the interface class 'libsbml'.  The names of the type codes all begin
        with the characters 'SBML_.'

        Returns the SBML type code for this object, or SBML_UNKNOWN (default).

        See also getElementName().

        """
        return _libsbml.ListOfCompartmentReferences_getTypeCode(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfCompartmentReferences self) -> int


        Returns the libSBML type code for the SBML objects contained in this
        ListOf object

        LibSBML attaches an identifying code to every kind of SBML object.
        These are known as SBML type codes.  In the Python language interface
        for libSBML, the type codes are defined as static integer constants in
        the interface class 'libsbml'.  The names of the type codes all begin
        with the characters 'SBML_.'

        Returns the SBML type code for the objects in this ListOf instance, or
        SBML_UNKNOWN (default).

        See also getElementName().

        """
        return _libsbml.ListOfCompartmentReferences_getItemTypeCode(self)

    __swig_destroy__ = _libsbml.delete_ListOfCompartmentReferences
    __del__ = lambda self: None
ListOfCompartmentReferences_swigregister = _libsbml.ListOfCompartmentReferences_swigregister
ListOfCompartmentReferences_swigregister(ListOfCompartmentReferences)

class SpeciesTypeInstance(SBase):
    """

    [SBML 'multi' package]  Allows construction of structured
    MultiSpeciesType objects.

    The SpeciesTypeInstance object is a child of MultiSpeciesType, and
    provides a way to construct MultiSpeciesType objects and Species with
    multiple components. A MultiSpeciesType can contain a list of
    instances of other MultiSpeciesType objects which can also have their
    own SpeciesTypeInstance objects, so the complete construct of a
    MultiSpeciesType has a tree structure. A MultiSpeciesType cannot
    contain an instance of any other MultiSpeciesType that already
    contains the instance of it. In other words, circular references are
    not allowed when constructing MultiSpeciesType objects. For example,
    if a MultiSpeciesType 'A' contains the instance of another
    MultiSpeciesType 'B', 'B' must not contain the instance of 'A'
    anywhere in the complete structure of 'B'. The optional attribute
    compartmentReference, of type SIdRef, can be used to indicate which
    sub-compartment in a composite compartment the SpeciesTypeInstance is
    located in.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SpeciesTypeInstance, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SpeciesTypeInstance, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(SpeciesTypeInstance self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> SpeciesTypeInstance
        __init__(SpeciesTypeInstance self, unsigned int level, unsigned int version) -> SpeciesTypeInstance
        __init__(SpeciesTypeInstance self, unsigned int level) -> SpeciesTypeInstance
        __init__(SpeciesTypeInstance self) -> SpeciesTypeInstance
        __init__(SpeciesTypeInstance self, MultiPkgNamespaces multins) -> SpeciesTypeInstance
        __init__(SpeciesTypeInstance self, SpeciesTypeInstance orig) -> SpeciesTypeInstance


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            SpeciesTypeInstance(long level      =
        MultiExtension.getDefaultLevel(), long version    =
        MultiExtension.getDefaultVersion(), long pkgVersion =
        MultiExtension.getDefaultPackageVersion())

        Creates a new SpeciesTypeInstance object.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            SpeciesTypeInstance(SpeciesTypeInstance orig)

        Copy constructor for SpeciesTypeInstance.

        Parameter 'orig' is the SpeciesTypeInstance instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            SpeciesTypeInstance(MultiPkgNamespaces multins)

        Creates a new SpeciesTypeInstance with the given MultiPkgNamespaces
        object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'multins' is the MultiPkgNamespaces object

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_SpeciesTypeInstance(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(SpeciesTypeInstance self) -> SpeciesTypeInstance


        Creates and returns a deep copy of this SpeciesTypeInstance object.

        Returns a (deep) copy of this SpeciesTypeInstance object.

        """
        return _libsbml.SpeciesTypeInstance_clone(self)

    __swig_destroy__ = _libsbml.delete_SpeciesTypeInstance
    __del__ = lambda self: None

    def getId(self):
        """
        getId(SpeciesTypeInstance self) -> string


        Returns the value of the 'id' attribute of this SpeciesTypeInstance.

        Returns the value of the 'id' attribute of this SpeciesTypeInstance as
        a string.

        """
        return _libsbml.SpeciesTypeInstance_getId(self)


    def isSetId(self):
        """
        isSetId(SpeciesTypeInstance self) -> bool


        Returns 'True' if this SpeciesTypeInstance's 'id' attribute has been
        set.

        Returns 'True' if this SpeciesTypeInstance's 'id' attribute has been
        set; otherwise, 'False' is returned.

        """
        return _libsbml.SpeciesTypeInstance_isSetId(self)


    def setId(self, id):
        """
        setId(SpeciesTypeInstance self, string id) -> int


        Sets the value of the 'id' attribute of this SpeciesTypeInstance.

        Parameter 'id' is string value of the 'id' attribute to be set

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.SpeciesTypeInstance_setId(self, id)


    def unsetId(self):
        """
        unsetId(SpeciesTypeInstance self) -> int


        Unsets the value of the 'id' attribute of this SpeciesTypeInstance.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.SpeciesTypeInstance_unsetId(self)


    def getName(self):
        """
        getName(SpeciesTypeInstance self) -> string


        Returns the value of the 'name' attribute of this SpeciesTypeInstance.

        Returns the value of the 'name' attribute of this SpeciesTypeInstance
        as a string.

        """
        return _libsbml.SpeciesTypeInstance_getName(self)


    def isSetName(self):
        """
        isSetName(SpeciesTypeInstance self) -> bool


        Returns 'True' if this SpeciesTypeInstance's 'name' attribute has been
        set.

        Returns 'True' if this SpeciesTypeInstance's 'name' attribute has been
        set; otherwise, 'False' is returned.

        """
        return _libsbml.SpeciesTypeInstance_isSetName(self)


    def setName(self, name):
        """
        setName(SpeciesTypeInstance self, string name) -> int


        Sets the value of the 'name' attribute of this SpeciesTypeInstance.

        Parameter 'name' is the new value for the attribute.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.SpeciesTypeInstance_setName(self, name)


    def unsetName(self):
        """
        unsetName(SpeciesTypeInstance self) -> int


        Unsets the value of the 'name' attribute of this SpeciesTypeInstance.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.SpeciesTypeInstance_unsetName(self)


    def getSpeciesType(self):
        """
        getSpeciesType(SpeciesTypeInstance self) -> string


        Returns the value of the 'speciesType' attribute of this
        SpeciesTypeInstance.

        Returns the value of the 'speciesType' attribute of this
        SpeciesTypeInstance as a string.

        """
        return _libsbml.SpeciesTypeInstance_getSpeciesType(self)


    def isSetSpeciesType(self):
        """
        isSetSpeciesType(SpeciesTypeInstance self) -> bool


        Returns 'True' if this SpeciesTypeInstance's 'speciesType' attribute
        has been set.

        Returns 'True' if this SpeciesTypeInstance's 'speciesType' attribute
        has been set; otherwise, 'False' is returned.

        """
        return _libsbml.SpeciesTypeInstance_isSetSpeciesType(self)


    def setSpeciesType(self, speciesType):
        """
        setSpeciesType(SpeciesTypeInstance self, string speciesType) -> int


        Sets the value of the 'speciesType' attribute of this
        SpeciesTypeInstance.

        Parameter 'speciesType' is the new value for the attribute.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.SpeciesTypeInstance_setSpeciesType(self, speciesType)


    def unsetSpeciesType(self):
        """
        unsetSpeciesType(SpeciesTypeInstance self) -> int


        Unsets the value of the 'speciesType' attribute of this
        SpeciesTypeInstance.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.SpeciesTypeInstance_unsetSpeciesType(self)


    def getCompartmentReference(self):
        """
        getCompartmentReference(SpeciesTypeInstance self) -> string


        Returns the value of the 'compartmentReference' attribute of this
        SpeciesTypeInstance.

        Returns the value of the 'compartmentReference' attribute of this
        SpeciesTypeInstance as a string.

        """
        return _libsbml.SpeciesTypeInstance_getCompartmentReference(self)


    def isSetCompartmentReference(self):
        """
        isSetCompartmentReference(SpeciesTypeInstance self) -> bool


        Returns 'True' if this SpeciesTypeInstance's 'compartmentReference'
        attribute has been set.

        Returns 'True' if this SpeciesTypeInstance's 'compartmentReference'
        attribute has been set; otherwise, 'False' is returned.

        """
        return _libsbml.SpeciesTypeInstance_isSetCompartmentReference(self)


    def setCompartmentReference(self, compartmentReference):
        """
        setCompartmentReference(SpeciesTypeInstance self, string compartmentReference) -> int


        Sets the value of the 'compartmentReference' attribute of this
        SpeciesTypeInstance.

        Parameter 'compartmentReference' is the new value for the attribute.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.SpeciesTypeInstance_setCompartmentReference(self, compartmentReference)


    def unsetCompartmentReference(self):
        """
        unsetCompartmentReference(SpeciesTypeInstance self) -> int


        Unsets the value of the 'compartmentReference' attribute of this
        SpeciesTypeInstance.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.SpeciesTypeInstance_unsetCompartmentReference(self)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(SpeciesTypeInstance self, string oldid, string newid)


        Renames all the 'SIdRef' attributes on this element, including any
        found in MathML content (if such exists).

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas, comparing the identifiers to the value of
        'oldid'.  If any matches are found, the matching identifiers are
        replaced with 'newid'.  The method does not descend into child
        elements.

        Parameter 'oldid' is the old identifier Parameter 'newid' is the new
        identifier

        """
        return _libsbml.SpeciesTypeInstance_renameSIdRefs(self, oldid, newid)


    def getElementName(self):
        """
        getElementName(SpeciesTypeInstance self) -> string


        Returns the XML element name of this object.

        Returns the name of this element, i.e. ''speciesTypeInstance'.'

        """
        return _libsbml.SpeciesTypeInstance_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(SpeciesTypeInstance self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object:
        SBML_MULTI_BINDING_SITE_SPECIES_TYPE.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.SpeciesTypeInstance_getTypeCode(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(SpeciesTypeInstance self) -> bool


        Predicate returning 'True' if all the required attributes for this
        SpeciesTypeInstance object have been set.

        Note: The required attributes for a SpeciesTypeInstance object are:

        * 'id'

        * 'speciesType'

        * 'occur'

        Returns a boolean value indicating whether all the required attributes
        for this object have been defined.

        """
        return _libsbml.SpeciesTypeInstance_hasRequiredAttributes(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(SpeciesTypeInstance self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.SpeciesTypeInstance_enablePackageInternal(self, pkgURI, pkgPrefix, flag)

SpeciesTypeInstance_swigregister = _libsbml.SpeciesTypeInstance_swigregister
SpeciesTypeInstance_swigregister(SpeciesTypeInstance)

class ListOfSpeciesTypeInstances(ListOf):
    """

    [SBML 'multi' package]  A list of SpeciesTypeInstance objects.

    The ListOfSpeciesTypeInstances is a container for SpeciesTypeInstance
    objects.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    See also SpeciesTypeInstance.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfSpeciesTypeInstances, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfSpeciesTypeInstances, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ListOfSpeciesTypeInstances self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ListOfSpeciesTypeInstances
        __init__(ListOfSpeciesTypeInstances self, unsigned int level, unsigned int version) -> ListOfSpeciesTypeInstances
        __init__(ListOfSpeciesTypeInstances self, unsigned int level) -> ListOfSpeciesTypeInstances
        __init__(ListOfSpeciesTypeInstances self) -> ListOfSpeciesTypeInstances
        __init__(ListOfSpeciesTypeInstances self, MultiPkgNamespaces multins) -> ListOfSpeciesTypeInstances


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfSpeciesTypeInstances(long level      =
        MultiExtension.getDefaultLevel(), long version    =
        MultiExtension.getDefaultVersion(), long pkgVersion =
        MultiExtension.getDefaultPackageVersion())

        Creates a new ListOfSpeciesTypeInstances object.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfSpeciesTypeInstances(MultiPkgNamespaces multins)

        Creates a new ListOfSpeciesTypeInstances with the given
        MultiPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'multins' is the MultiPkgNamespaces object

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_ListOfSpeciesTypeInstances(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ListOfSpeciesTypeInstances self) -> ListOfSpeciesTypeInstances


        Creates and returns a deep copy of this ListOfSpeciesTypeInstances
        object.

        Returns a (deep) copy of this ListOfSpeciesTypeInstances object.

        """
        return _libsbml.ListOfSpeciesTypeInstances_clone(self)


    def get(self, *args):
        """
        get(ListOfSpeciesTypeInstances self, unsigned int n) -> SpeciesTypeInstance
        get(ListOfSpeciesTypeInstances self, unsigned int n) -> SpeciesTypeInstance
        get(ListOfSpeciesTypeInstances self, string sid) -> SpeciesTypeInstance
        get(ListOfSpeciesTypeInstances self, string sid) -> SpeciesTypeInstance


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get the nth SpeciesTypeInstance object from the
        ListOfSpeciesTypeInstances.

        Parameter 'n' is the index number of the SpeciesTypeInstance to get.

        Returns the nth object, or 'None' if the index 'is' out of range.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get the SpeciesTypeInstance object with the given identifier 'sid'.

        Parameter 'sid' is a string representing the identifier of the
        SpeciesTypeInstance to get.

        Returns the object with the given id, or 'None' if no such object
        exists.

        See also get()   *, size().

        """
        return _libsbml.ListOfSpeciesTypeInstances_get(self, *args)


    def remove(self, *args):
        """
        remove(ListOfSpeciesTypeInstances self, unsigned int n) -> SpeciesTypeInstance
        remove(ListOfSpeciesTypeInstances self, string sid) -> SpeciesTypeInstance


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth SpeciesTypeInstance object from this
        ListOfSpeciesTypeInstances.

        Parameter 'n' is the index of the SpeciesTypeInstance to remove.

        Returns the object removed, or 'None' if no such object exists.  Note
        that the caller owns the returned object and is responsible for
        deleting it.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes the SpeciesTypeInstance object with the given identifier
        'sid'.

        Parameter 'sid' is the identifier of the SpeciesTypeInstance to
        remove.

        Returns the object removed, or 'None' if no such object exists.  Note
        that the caller owns the returned object and is responsible for
        deleting it.

        """
        return _libsbml.ListOfSpeciesTypeInstances_remove(self, *args)


    def getElementName(self):
        """
        getElementName(ListOfSpeciesTypeInstances self) -> string


        Returns the XML element name of this object.

        Returns the name of this element, i.e. ''listOfSpeciesTypeInstances'.'

        """
        return _libsbml.ListOfSpeciesTypeInstances_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(ListOfSpeciesTypeInstances self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object:
        SBML_MULTI_BINDING_SITE_SPECIES_TYPE.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfSpeciesTypeInstances_getTypeCode(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfSpeciesTypeInstances self) -> int


        Returns the libSBML type code for the objects contained in this ListOf
        (i.e., Compartment objects, if the list is non-empty).

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for the objects contained in this ListOf
        instance: SBML_COMPARTMENT (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfSpeciesTypeInstances_getItemTypeCode(self)

    __swig_destroy__ = _libsbml.delete_ListOfSpeciesTypeInstances
    __del__ = lambda self: None
ListOfSpeciesTypeInstances_swigregister = _libsbml.ListOfSpeciesTypeInstances_swigregister
ListOfSpeciesTypeInstances_swigregister(ListOfSpeciesTypeInstances)

class InSpeciesTypeBond(SBase):
    """

    [SBML 'multi' package]  Defines a bond within a MultiSpeciesType.

    The InSpeciesTypeBond object is a child of MultiSpeciesType, and
    defines a bond existing within that MultiSpeciesType. The bond
    therefore exists in every species that references the
    MultiSpeciesType.  The binding relationship in an InSpeciesTypeBond is
    one-to-one. The uniqueness of an InSpeciesTypeBond is ensured by the
    pair of referenced attributes 'bindingSite1' and 'bindingSite2', both
    of type SBaseRef.  The referenced identifiers of the binding sites can
    be the ids of SpeciesTypeInstance objects (binding sites), or the ids
    of the SpeciesTypeComponentIndex objects indexing the binding sites
    and the ultimately referenced components must be the
    BindingSiteSpeciesType objects. Obviously, attributes 'bindingSite1'
    and 'bindingSite2' must not reference the same BindingSiteSpeciesType
    object.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InSpeciesTypeBond, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, InSpeciesTypeBond, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(InSpeciesTypeBond self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> InSpeciesTypeBond
        __init__(InSpeciesTypeBond self, unsigned int level, unsigned int version) -> InSpeciesTypeBond
        __init__(InSpeciesTypeBond self, unsigned int level) -> InSpeciesTypeBond
        __init__(InSpeciesTypeBond self) -> InSpeciesTypeBond
        __init__(InSpeciesTypeBond self, MultiPkgNamespaces multins) -> InSpeciesTypeBond
        __init__(InSpeciesTypeBond self, InSpeciesTypeBond orig) -> InSpeciesTypeBond


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            InSpeciesTypeBond(InSpeciesTypeBond orig)

        Copy constructor for InSpeciesTypeBond.

        Parameter 'orig' is the InSpeciesTypeBond instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            InSpeciesTypeBond(long level      =
        MultiExtension.getDefaultLevel(), long version    =
        MultiExtension.getDefaultVersion(), long pkgVersion =
        MultiExtension.getDefaultPackageVersion())

        Creates a new InSpeciesTypeBond object.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            InSpeciesTypeBond(MultiPkgNamespaces multins)

        Creates a new InSpeciesTypeBond with the given MultiPkgNamespaces
        object.

        Parameter 'multins' is the MultiPkgNamespaces object

        """
        this = _libsbml.new_InSpeciesTypeBond(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(InSpeciesTypeBond self) -> InSpeciesTypeBond


        Creates and returns a deep copy of this InSpeciesTypeBond object.

        Returns a (deep) copy of this InSpeciesTypeBond object.

        """
        return _libsbml.InSpeciesTypeBond_clone(self)

    __swig_destroy__ = _libsbml.delete_InSpeciesTypeBond
    __del__ = lambda self: None

    def getId(self):
        """
        getId(InSpeciesTypeBond self) -> string


        Returns the value of the 'id' attribute of this InSpeciesTypeBond.

        Returns the value of the 'id' attribute of this InSpeciesTypeBond as a
        string.

        """
        return _libsbml.InSpeciesTypeBond_getId(self)


    def isSetId(self):
        """
        isSetId(InSpeciesTypeBond self) -> bool


        Returns 'True' if this InSpeciesTypeBond's 'id' attribute has been
        set.

        Returns 'True' if this InSpeciesTypeBond's 'id' attribute has been
        set; otherwise, 'False' is returned.

        """
        return _libsbml.InSpeciesTypeBond_isSetId(self)


    def setId(self, id):
        """
        setId(InSpeciesTypeBond self, string id) -> int


        Sets the value of the 'id' attribute of this InSpeciesTypeBond.

        Parameter 'id' is string value of the 'id' attribute to be set

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.InSpeciesTypeBond_setId(self, id)


    def unsetId(self):
        """
        unsetId(InSpeciesTypeBond self) -> int


        Unsets the value of the 'id' attribute of this InSpeciesTypeBond.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.InSpeciesTypeBond_unsetId(self)


    def getName(self):
        """
        getName(InSpeciesTypeBond self) -> string


        Returns the value of the 'name' attribute of this InSpeciesTypeBond.

        Returns the value of the 'name' attribute of this InSpeciesTypeBond as
        a string.

        """
        return _libsbml.InSpeciesTypeBond_getName(self)


    def isSetName(self):
        """
        isSetName(InSpeciesTypeBond self) -> bool


        Returns 'True' if this InSpeciesTypeBond's 'name' attribute has been
        set.

        Returns 'True' if this InSpeciesTypeBond's 'name' attribute has been
        set; otherwise, 'False' is returned.

        """
        return _libsbml.InSpeciesTypeBond_isSetName(self)


    def setName(self, name):
        """
        setName(InSpeciesTypeBond self, string name) -> int


        Sets the value of the 'name' attribute of this InSpeciesTypeBond.

        Parameter 'name' is string value of the 'name' attribute to be set

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.InSpeciesTypeBond_setName(self, name)


    def unsetName(self):
        """
        unsetName(InSpeciesTypeBond self) -> int


        Unsets the value of the 'name' attribute of this InSpeciesTypeBond.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.InSpeciesTypeBond_unsetName(self)


    def getBindingSite1(self):
        """
        getBindingSite1(InSpeciesTypeBond self) -> string


        Returns the value of the 'bindingSite1' attribute of this
        InSpeciesTypeBond.

        Returns the value of the 'bindingSite1' attribute of this
        InSpeciesTypeBond as a string.

        """
        return _libsbml.InSpeciesTypeBond_getBindingSite1(self)


    def isSetBindingSite1(self):
        """
        isSetBindingSite1(InSpeciesTypeBond self) -> bool


        Returns 'True' if this InSpeciesTypeBond's 'bindingSite1' attribute
        has been set.

        Returns 'True' if this InSpeciesTypeBond's 'bindingSite1' attribute
        has been set; otherwise, 'False' is returned.

        """
        return _libsbml.InSpeciesTypeBond_isSetBindingSite1(self)


    def setBindingSite1(self, bindingSite1):
        """
        setBindingSite1(InSpeciesTypeBond self, string bindingSite1) -> int


        Sets the value of the 'bindingSite1' attribute of this
        InSpeciesTypeBond.

        Parameter 'bindingSite1' is the new value for the 'bindingSite1'
        attribute.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.InSpeciesTypeBond_setBindingSite1(self, bindingSite1)


    def unsetBindingSite1(self):
        """
        unsetBindingSite1(InSpeciesTypeBond self) -> int


        Unsets the value of the 'bindingSite1' attribute of this
        InSpeciesTypeBond.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.InSpeciesTypeBond_unsetBindingSite1(self)


    def getBindingSite2(self):
        """
        getBindingSite2(InSpeciesTypeBond self) -> string


        Returns the value of the 'bindingSite2' attribute of this
        InSpeciesTypeBond.

        Returns the value of the 'bindingSite2' attribute of this
        InSpeciesTypeBond as a string.

        """
        return _libsbml.InSpeciesTypeBond_getBindingSite2(self)


    def isSetBindingSite2(self):
        """
        isSetBindingSite2(InSpeciesTypeBond self) -> bool


        Returns 'True' if this InSpeciesTypeBond's 'bindingSite2' attribute
        has been set.

        Returns 'True' if this InSpeciesTypeBond's 'bindingSite2' attribute
        has been set; otherwise, 'False' is returned.

        """
        return _libsbml.InSpeciesTypeBond_isSetBindingSite2(self)


    def setBindingSite2(self, bindingSite2):
        """
        setBindingSite2(InSpeciesTypeBond self, string bindingSite2) -> int


        Sets the value of the 'bindingSite2' attribute of this
        InSpeciesTypeBond.

        Parameter 'bindingSite2' is the new value of the 'bindingSite2'
        attribute.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.InSpeciesTypeBond_setBindingSite2(self, bindingSite2)


    def unsetBindingSite2(self):
        """
        unsetBindingSite2(InSpeciesTypeBond self) -> int


        Unsets the value of the 'bindingSite2' attribute of this
        InSpeciesTypeBond.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.InSpeciesTypeBond_unsetBindingSite2(self)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(InSpeciesTypeBond self, string oldid, string newid)


        Renames all the 'SIdRef' attributes on this element, including any
        found in MathML content (if such exists).

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas, comparing the identifiers to the value of
        'oldid'.  If any matches are found, the matching identifiers are
        replaced with 'newid'.  The method does not descend into child
        elements.

        Parameter 'oldid' is the old identifier Parameter 'newid' is the new
        identifier

        """
        return _libsbml.InSpeciesTypeBond_renameSIdRefs(self, oldid, newid)


    def getElementName(self):
        """
        getElementName(InSpeciesTypeBond self) -> string


        Returns the XML element name of this object.

        Returns the name of this element, i.e. ''inSpeciesTypeBond'.'

        """
        return _libsbml.InSpeciesTypeBond_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(InSpeciesTypeBond self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object:
        SBML_MULTI_BINDING_SITE_SPECIES_TYPE.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.InSpeciesTypeBond_getTypeCode(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(InSpeciesTypeBond self) -> bool


        Predicate returning 'True' if all the required attributes for this
        InSpeciesTypeBond object have been set.

        Note: The required attributes for a InSpeciesTypeBond object are:

        * 'bindingSite1'

        * 'bindingSite2'

        Returns a boolean value indicating whether all the required attributes
        for this object have been defined.

        """
        return _libsbml.InSpeciesTypeBond_hasRequiredAttributes(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(InSpeciesTypeBond self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.InSpeciesTypeBond_enablePackageInternal(self, pkgURI, pkgPrefix, flag)

InSpeciesTypeBond_swigregister = _libsbml.InSpeciesTypeBond_swigregister
InSpeciesTypeBond_swigregister(InSpeciesTypeBond)

class ListOfInSpeciesTypeBonds(ListOf):
    """

    [SBML 'multi' package]  A list of InSpeciesTypeBond objects.

    The ListOfInSpeciesTypeBonds is a container for InSpeciesTypeBond
    objects.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    See also InSpeciesTypeBond.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfInSpeciesTypeBonds, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfInSpeciesTypeBonds, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ListOfInSpeciesTypeBonds self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ListOfInSpeciesTypeBonds
        __init__(ListOfInSpeciesTypeBonds self, unsigned int level, unsigned int version) -> ListOfInSpeciesTypeBonds
        __init__(ListOfInSpeciesTypeBonds self, unsigned int level) -> ListOfInSpeciesTypeBonds
        __init__(ListOfInSpeciesTypeBonds self) -> ListOfInSpeciesTypeBonds
        __init__(ListOfInSpeciesTypeBonds self, MultiPkgNamespaces multins) -> ListOfInSpeciesTypeBonds


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfInSpeciesTypeBonds(long level      =
        MultiExtension.getDefaultLevel(), long version    =
        MultiExtension.getDefaultVersion(), long pkgVersion =
        MultiExtension.getDefaultPackageVersion())

        Creates a new ListOfInSpeciesTypeBonds with the given level, version,
        and package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        ListOfInSpeciesTypeBonds

        Parameter 'version' is a long integer, the SBML Version to assign to
        this ListOfInSpeciesTypeBonds

        Parameter 'pkgVersion' is a long integer, the SBML Multi Version to
        assign to this ListOfInSpeciesTypeBonds

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfInSpeciesTypeBonds(MultiPkgNamespaces multins)

        Creates a new ListOfInSpeciesTypeBonds with the given
        MultiPkgNamespaces object.

        Parameter 'multins' is the MultiPkgNamespaces object

        """
        this = _libsbml.new_ListOfInSpeciesTypeBonds(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ListOfInSpeciesTypeBonds self) -> ListOfInSpeciesTypeBonds


        Creates and returns a deep copy of this ListOfInSpeciesTypeBonds
        object.

        Returns a (deep) copy of this ListOfInSpeciesTypeBonds object.

        """
        return _libsbml.ListOfInSpeciesTypeBonds_clone(self)


    def get(self, *args):
        """
        get(ListOfInSpeciesTypeBonds self, unsigned int n) -> InSpeciesTypeBond
        get(ListOfInSpeciesTypeBonds self, unsigned int n) -> InSpeciesTypeBond
        get(ListOfInSpeciesTypeBonds self, string sid) -> InSpeciesTypeBond
        get(ListOfInSpeciesTypeBonds self, string sid) -> InSpeciesTypeBond


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a InSpeciesTypeBond from the ListOfInSpeciesTypeBonds.

        Parameter 'n' is the index number of the InSpeciesTypeBond to get.

        Returns the nth InSpeciesTypeBond in this ListOfInSpeciesTypeBonds. If
        the index 'n' is invalid, 'None' is returned.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a InSpeciesTypeBond from the ListOfInSpeciesTypeBonds based on its
        identifier.

        Parameter 'sid' is a string representing the identifier of the
        InSpeciesTypeBond to get.

        Returns InSpeciesTypeBond in this ListOfInSpeciesTypeBonds with the
        given id or 'None' if no such InSpeciesTypeBond exists.

        See also get()   *, size().

        """
        return _libsbml.ListOfInSpeciesTypeBonds_get(self, *args)


    def remove(self, *args):
        """
        remove(ListOfInSpeciesTypeBonds self, unsigned int n) -> InSpeciesTypeBond
        remove(ListOfInSpeciesTypeBonds self, string sid) -> InSpeciesTypeBond


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth InSpeciesTypeBond from this ListOfInSpeciesTypeBonds
        and returns a pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the InSpeciesTypeBond to remove.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes the InSpeciesTypeBond from this ListOfInSpeciesTypeBonds with
        the given identifier and returns a pointer to it.

        The caller owns the returned item and is responsible for deleting it.
        If none of the items in this list have the identifier 'sid', then
        'None' is returned.

        Parameter 'sid' is the identifier of the InSpeciesTypeBond to remove.

        Returns the InSpeciesTypeBond removed. As mentioned above, the caller
        owns the returned item.

        """
        return _libsbml.ListOfInSpeciesTypeBonds_remove(self, *args)


    def getElementName(self):
        """
        getElementName(ListOfInSpeciesTypeBonds self) -> string


        Returns the XML element name of this object, which for
        ListOfInSpeciesTypeBonds, is always ''listOfInSpeciesTypeBonds'.'

        Returns the name of this element, i.e. ''listOfInSpeciesTypeBonds'.'

        """
        return _libsbml.ListOfInSpeciesTypeBonds_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(ListOfInSpeciesTypeBonds self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are known as SBML type codes.  In the Python language interface
        for libSBML, the type codes are defined as static integer constants in
        the interface class 'libsbml'.  The names of the type codes all begin
        with the characters 'SBML_.'

        Returns the SBML type code for this object, or SBML_UNKNOWN (default).

        See also getElementName().

        """
        return _libsbml.ListOfInSpeciesTypeBonds_getTypeCode(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfInSpeciesTypeBonds self) -> int


        Returns the libSBML type code for the SBML objects contained in this
        ListOf object

        LibSBML attaches an identifying code to every kind of SBML object.
        These are known as SBML type codes.  In the Python language interface
        for libSBML, the type codes are defined as static integer constants in
        the interface class 'libsbml'.  The names of the type codes all begin
        with the characters 'SBML_.'

        Returns the SBML type code for the objects in this ListOf instance, or
        SBML_UNKNOWN (default).

        See also getElementName().

        """
        return _libsbml.ListOfInSpeciesTypeBonds_getItemTypeCode(self)

    __swig_destroy__ = _libsbml.delete_ListOfInSpeciesTypeBonds
    __del__ = lambda self: None
ListOfInSpeciesTypeBonds_swigregister = _libsbml.ListOfInSpeciesTypeBonds_swigregister
ListOfInSpeciesTypeBonds_swigregister(ListOfInSpeciesTypeBonds)

MULTI_BINDING_STATUS_BOUND = _libsbml.MULTI_BINDING_STATUS_BOUND
MULTI_BINDING_STATUS_UNBOUND = _libsbml.MULTI_BINDING_STATUS_UNBOUND
MULTI_BINDING_STATUS_EITHER = _libsbml.MULTI_BINDING_STATUS_EITHER
MULTI_BINDING_STATUS_UNKNOWN = _libsbml.MULTI_BINDING_STATUS_UNKNOWN
class OutwardBindingSite(SBase):
    """

    [SBML 'multi' package]  Defines a outward-facing binding site for a
    MultiSpeciesType.

    The OutwardBindingSite object is a child of a Species (via the
    MultiSpeciesPlugin).  It has two optional attributes, 'id' and 'name',
    and two required attributes, 'bindingStatus' and 'component'. A
    binding site not involved in any InSpeciesTypeBond object in the
    MultiSpeciesType referenced by a Species is an OutwardBindingSite. The
    bindingStatus attribute is of type BindingStatus_t.  The component
    attribute, of type SIdRef, references a component which ultimately
    references a BindingSiteSpeciesType object. The attribute value must
    be the identifier of a SpeciesTypeInstance, SpeciesTypeComponentIndex
    or MultiSpeciesType object. An OutwardBindingSite cannot be a binding
    site referenced by any InSpeciesTypeBond in the species. There are
    three scenarios for the component attribute to have the value of an
    identifier of MultiSpeciesType, SpeciesTypeInstance, or
    SpeciesTypeComponentIndex respectively:

    * When a Species references a simple BindingSiteSpeciesType, the value
    of the component attribute of the OutwardBindingSite of the Species
    can only be the id of the referenced MultiSpeciesType.

    * When a Species references a MultiSpeciesType with a
    SpeciesTypeInstance being a binding site (have an id of
    BindingSiteSpeciesType as its 'speciesType' attribute) and the id of
    the SpeciesTypeInstance can identify the binding site within the
    MultiSpeciesType (referenced by the Species) unambiguously, and
    therefore, the value of the component attribute of an
    OutwardBindingSite of the species can be the id of the
    SpeciesTypeInstance.

    * When a Species references a MultiSpeciesType with a
    SpeciesTypeInstance being a binding site (directly or indirectly) and
    id of the SpeciesTypeInstance can NOT identify the binding site
    without ambiguity, an id of SpeciesTypeComponentIndex can be used as
    the value of the component attribute of an OutwardBindingSite of the
    Species.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, OutwardBindingSite, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, OutwardBindingSite, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(OutwardBindingSite self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> OutwardBindingSite
        __init__(OutwardBindingSite self, unsigned int level, unsigned int version) -> OutwardBindingSite
        __init__(OutwardBindingSite self, unsigned int level) -> OutwardBindingSite
        __init__(OutwardBindingSite self) -> OutwardBindingSite
        __init__(OutwardBindingSite self, MultiPkgNamespaces multins) -> OutwardBindingSite
        __init__(OutwardBindingSite self, OutwardBindingSite orig) -> OutwardBindingSite


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            OutwardBindingSite(OutwardBindingSite orig)

        Copy constructor for OutwardBindingSite.

        Parameter 'orig' is the OutwardBindingSite instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            OutwardBindingSite(long level      =
        MultiExtension.getDefaultLevel(), long version    =
        MultiExtension.getDefaultVersion(), long pkgVersion =
        MultiExtension.getDefaultPackageVersion())

        Creates a new OutwardBindingSite object.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            OutwardBindingSite(MultiPkgNamespaces multins)

        Creates a new OutwardBindingSite with the given MultiPkgNamespaces
        object.

        Parameter 'multins' is the MultiPkgNamespaces object

        """
        this = _libsbml.new_OutwardBindingSite(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(OutwardBindingSite self) -> OutwardBindingSite


        Creates and returns a deep copy of this OutwardBindingSite object.

        Returns a (deep) copy of this OutwardBindingSite object.

        """
        return _libsbml.OutwardBindingSite_clone(self)

    __swig_destroy__ = _libsbml.delete_OutwardBindingSite
    __del__ = lambda self: None

    def getId(self):
        """
        getId(OutwardBindingSite self) -> string


        Returns the value of the 'id' attribute of this OutwardBindingSite.

        Returns the value of the 'id' attribute of this OutwardBindingSite as
        a string.

        """
        return _libsbml.OutwardBindingSite_getId(self)


    def isSetId(self):
        """
        isSetId(OutwardBindingSite self) -> bool


        Returns 'True' if this OutwardBindingSite's 'id' attribute has been
        set.

        Returns 'True' if this OutwardBindingSite's 'id' attribute has been
        set, otherwise 'False' is returned.

        """
        return _libsbml.OutwardBindingSite_isSetId(self)


    def setId(self, id):
        """
        setId(OutwardBindingSite self, string id) -> int


        Sets the value of the 'id' attribute of this OutwardBindingSite.

        Parameter 'id' is string value of the 'id' attribute to be set

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.OutwardBindingSite_setId(self, id)


    def unsetId(self):
        """
        unsetId(OutwardBindingSite self) -> int


        Unsets the value of the 'id' attribute of this OutwardBindingSite.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.OutwardBindingSite_unsetId(self)


    def getName(self):
        """
        getName(OutwardBindingSite self) -> string


        Returns the value of the 'name' attribute of this OutwardBindingSite.

        Returns the value of the 'name' attribute of this OutwardBindingSite
        as a string.

        """
        return _libsbml.OutwardBindingSite_getName(self)


    def isSetName(self):
        """
        isSetName(OutwardBindingSite self) -> bool


        Returns 'True' if this OutwardBindingSite's 'name' attribute has been
        set.

        Returns 'True' if this OutwardBindingSite's 'name' attribute has been
        set, otherwise 'False' is returned.

        """
        return _libsbml.OutwardBindingSite_isSetName(self)


    def setName(self, name):
        """
        setName(OutwardBindingSite self, string name) -> int


        Sets the value of the 'name' attribute of this OutwardBindingSite.

        Parameter 'name' is string value of the 'name' attribute to be set

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.OutwardBindingSite_setName(self, name)


    def unsetName(self):
        """
        unsetName(OutwardBindingSite self) -> int


        Unsets the value of the 'name' attribute of this OutwardBindingSite.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.OutwardBindingSite_unsetName(self)


    def getBindingStatus(self):
        """
        getBindingStatus(OutwardBindingSite self) -> BindingStatus_t


        Returns the value of the 'bindingStatus' attribute of this
        OutwardBindingSite.

        Returns the value of the 'bindingStatus' attribute of this
        OutwardBindingSite.

        """
        return _libsbml.OutwardBindingSite_getBindingStatus(self)


    def isSetBindingStatus(self):
        """
        isSetBindingStatus(OutwardBindingSite self) -> bool


        Returns 'True' if this OutwardBindingSite's 'bindingStatus' attribute
        has been set.

        Returns 'True' if this OutwardBindingSite's 'bindingStatus' attribute
        has been set, otherwise 'False' is returned.

        """
        return _libsbml.OutwardBindingSite_isSetBindingStatus(self)


    def setBindingStatus(self, *args):
        """
        setBindingStatus(OutwardBindingSite self, BindingStatus_t bindingStatus) -> int
        setBindingStatus(OutwardBindingSite self, string bindingStatus) -> int


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            setBindingStatus(BindingStatus_t bindingStatus)

        Sets the value of the 'bindingStatus' attribute of this
        OutwardBindingSite.

        Parameter 'bindingStatus' is the new value of the 'bindingStatus'
        attribute.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        ______________________________________________________________________
        Method variant with the following signature:

            setBindingStatus(string bindingStatus)

        Sets the value of the 'bindingStatus' attribute of this
        OutwardBindingSite.

        Parameter 'bindingStatus' is string& of the 'bindingStatus' attribute
        to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        The attribute 'bindingStatus' on a OutwardBindingSite object is used
        to describe the status of the binding site.

        In the SBML Level 3 Version 1 Multi specification, the following are
        the allowable values for 'bindingStatus':

        * ''bound',' the binding site is bound.

        * ''unbound',' the binding site is not bound.

        * ''either',' the binding site may either be bound or unbound.

        """
        return _libsbml.OutwardBindingSite_setBindingStatus(self, *args)


    def unsetBindingStatus(self):
        """
        unsetBindingStatus(OutwardBindingSite self) -> int


        Unsets the value of the 'bindingStatus' attribute of this
        OutwardBindingSite.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.OutwardBindingSite_unsetBindingStatus(self)


    def getComponent(self):
        """
        getComponent(OutwardBindingSite self) -> string


        Returns the value of the 'component' attribute of this
        OutwardBindingSite.

        Returns the value of the 'component' attribute of this
        OutwardBindingSite as a string.

        """
        return _libsbml.OutwardBindingSite_getComponent(self)


    def isSetComponent(self):
        """
        isSetComponent(OutwardBindingSite self) -> bool


        Returns 'True' if this OutwardBindingSite's 'component' attribute has
        been set.

        Returns 'True' if this OutwardBindingSite's 'component' attribute has
        been set; otherwise, 'False' is returned.

        """
        return _libsbml.OutwardBindingSite_isSetComponent(self)


    def setComponent(self, component):
        """
        setComponent(OutwardBindingSite self, string component) -> int


        Sets the value of the 'component' attribute of this
        OutwardBindingSite.

        Parameter 'component' is string value of the 'component' attribute to
        be set

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.OutwardBindingSite_setComponent(self, component)


    def unsetComponent(self):
        """
        unsetComponent(OutwardBindingSite self) -> int


        Unsets the value of the 'component' attribute of this
        OutwardBindingSite.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.OutwardBindingSite_unsetComponent(self)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(OutwardBindingSite self, string oldid, string newid)


        Renames all the 'SIdRef' attributes on this element, including any
        found in MathML content (if such exists).

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas, comparing the identifiers to the value of
        'oldid'.  If any matches are found, the matching identifiers are
        replaced with 'newid'.  The method does not descend into child
        elements.

        Parameter 'oldid' is the old identifier Parameter 'newid' is the new
        identifier

        """
        return _libsbml.OutwardBindingSite_renameSIdRefs(self, oldid, newid)


    def getElementName(self):
        """
        getElementName(OutwardBindingSite self) -> string


        Returns the XML element name of this object.

        Returns the name of this element, i.e. ''outwardBindingSite'.'

        """
        return _libsbml.OutwardBindingSite_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(OutwardBindingSite self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object:
        SBML_MULTI_BINDING_SITE_SPECIES_TYPE.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.OutwardBindingSite_getTypeCode(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(OutwardBindingSite self) -> bool


        Predicate returning 'True' if all the required attributes for this
        OutwardBindingSite object have been set.

        Note: The required attributes for a OutwardBindingSite object are:

        * 'bindingStatus'

        * 'component'

        Returns a boolean value indicating whether all the required attributes
        for this object have been defined.

        """
        return _libsbml.OutwardBindingSite_hasRequiredAttributes(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(OutwardBindingSite self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.OutwardBindingSite_enablePackageInternal(self, pkgURI, pkgPrefix, flag)

OutwardBindingSite_swigregister = _libsbml.OutwardBindingSite_swigregister
OutwardBindingSite_swigregister(OutwardBindingSite)

class ListOfOutwardBindingSites(ListOf):
    """

    [SBML 'multi' package]  A list of OutwardBindingSite objects.

    The ListOfOutwardBindingSites is a container for OutwardBindingSite
    objects.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    See also OutwardBindingSite.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfOutwardBindingSites, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfOutwardBindingSites, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ListOfOutwardBindingSites self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ListOfOutwardBindingSites
        __init__(ListOfOutwardBindingSites self, unsigned int level, unsigned int version) -> ListOfOutwardBindingSites
        __init__(ListOfOutwardBindingSites self, unsigned int level) -> ListOfOutwardBindingSites
        __init__(ListOfOutwardBindingSites self) -> ListOfOutwardBindingSites
        __init__(ListOfOutwardBindingSites self, MultiPkgNamespaces multins) -> ListOfOutwardBindingSites


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfOutwardBindingSites(long level      =
        MultiExtension.getDefaultLevel(), long version    =
        MultiExtension.getDefaultVersion(), long pkgVersion =
        MultiExtension.getDefaultPackageVersion())

        Creates a new ListOfOutwardBindingSites with the given level, version,
        and package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        ListOfOutwardBindingSites

        Parameter 'version' is a long integer, the SBML Version to assign to
        this ListOfOutwardBindingSites

        Parameter 'pkgVersion' is a long integer, the SBML Multi Version to
        assign to this ListOfOutwardBindingSites

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfOutwardBindingSites(MultiPkgNamespaces multins)

        Creates a new ListOfOutwardBindingSites with the given
        MultiPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'multins' is the MultiPkgNamespaces object

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_ListOfOutwardBindingSites(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ListOfOutwardBindingSites self) -> ListOfOutwardBindingSites


        Creates and returns a deep copy of this ListOfOutwardBindingSites
        object.

        Returns a (deep) copy of this ListOfOutwardBindingSites object.

        """
        return _libsbml.ListOfOutwardBindingSites_clone(self)


    def get(self, *args):
        """
        get(ListOfOutwardBindingSites self, unsigned int n) -> OutwardBindingSite
        get(ListOfOutwardBindingSites self, unsigned int n) -> OutwardBindingSite
        get(ListOfOutwardBindingSites self, string sid) -> OutwardBindingSite
        get(ListOfOutwardBindingSites self, string sid) -> OutwardBindingSite


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a OutwardBindingSite from the ListOfOutwardBindingSites.

        Parameter 'n' is the index number of the OutwardBindingSite to get.

        Returns the nth OutwardBindingSite in this ListOfOutwardBindingSites.
        If the index 'n' is invalid, 'None' is returned.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a OutwardBindingSite from the ListOfOutwardBindingSites based on
        its identifier.

        Parameter 'sid' is a string representing the identifier of the
        OutwardBindingSite to get.

        Returns OutwardBindingSite in this ListOfOutwardBindingSites with the
        given id or 'None' if no such OutwardBindingSite exists.

        See also get()   *, size().

        """
        return _libsbml.ListOfOutwardBindingSites_get(self, *args)


    def remove(self, *args):
        """
        remove(ListOfOutwardBindingSites self, unsigned int n) -> OutwardBindingSite
        remove(ListOfOutwardBindingSites self, string sid) -> OutwardBindingSite


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth OutwardBindingSite from this ListOfOutwardBindingSites
        and returns a pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the OutwardBindingSite to remove.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes the OutwardBindingSite from this ListOfOutwardBindingSites
        with the given identifier and returns a pointer to it.

        The caller owns the returned item and is responsible for deleting it.
        If none of the items in this list have the identifier 'sid', then
        'None' is returned.

        Parameter 'sid' is the identifier of the OutwardBindingSite to remove.

        Returns the OutwardBindingSite removed. As mentioned above, the caller
        owns the returned item.

        """
        return _libsbml.ListOfOutwardBindingSites_remove(self, *args)


    def getElementName(self):
        """
        getElementName(ListOfOutwardBindingSites self) -> string


        Returns the XML element name of this object, which for
        ListOfOutwardBindingSites, is always ''listOfOutwardBindingSites'.'

        Returns the name of this element, i.e. ''listOfOutwardBindingSites'.'

        """
        return _libsbml.ListOfOutwardBindingSites_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(ListOfOutwardBindingSites self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are known as SBML type codes.  In the Python language interface
        for libSBML, the type codes are defined as static integer constants in
        the interface class 'libsbml'.  The names of the type codes all begin
        with the characters 'SBML_.'

        Returns the SBML type code for this object, or SBML_UNKNOWN (default).

        See also getElementName().

        """
        return _libsbml.ListOfOutwardBindingSites_getTypeCode(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfOutwardBindingSites self) -> int


        Returns the libSBML type code for the SBML objects contained in this
        ListOf object

        LibSBML attaches an identifying code to every kind of SBML object.
        These are known as SBML type codes.  In the Python language interface
        for libSBML, the type codes are defined as static integer constants in
        the interface class 'libsbml'.  The names of the type codes all begin
        with the characters 'SBML_.'

        Returns the SBML type code for the objects in this ListOf instance, or
        SBML_UNKNOWN (default).

        See also getElementName().

        """
        return _libsbml.ListOfOutwardBindingSites_getItemTypeCode(self)

    __swig_destroy__ = _libsbml.delete_ListOfOutwardBindingSites
    __del__ = lambda self: None
ListOfOutwardBindingSites_swigregister = _libsbml.ListOfOutwardBindingSites_swigregister
ListOfOutwardBindingSites_swigregister(ListOfOutwardBindingSites)


def BindingStatus_toString(bindingStatus):
    """
    BindingStatus_toString(BindingStatus_t bindingStatus) -> char const *




    """
    return _libsbml.BindingStatus_toString(bindingStatus)

def BindingStatus_fromString(s):
    """
    BindingStatus_fromString(char const * s) -> BindingStatus_t




    """
    return _libsbml.BindingStatus_fromString(s)
class SpeciesFeatureType(SBase):
    """

    [SBML 'multi' package]  Defines a template for referencing
    SpeciesFeature objects.

    The SpeciesFeatureType object is a child of a MultiSpeciesType, and
    serves to provide frameworks or templates to define the referencing
    SpeciesFeature objects. SpeciesFeatureType has two required attributes
    'id' and 'occur', an optional attribute 'name', and a required child
    ListOfPossibleSpeciesFeatureValues. The multiple
    PossibleSpeciesFeatureValue children of the
    ListOfPossibleSpeciesFeatureValues object permit constructing
    multistate species via its SpeciesFeature children of the
    ListOfSpeciesFeatures or SubListOfSpeciesFeatures object.  The 'occur'
    attribute is used to indicate the number of instances of the
    SpeciesFeatureType. This attribute can be used to infer the number of
    the instances in the 'don't care' state in a referencing
    SpeciesFeature.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SpeciesFeatureType, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SpeciesFeatureType, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(SpeciesFeatureType self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> SpeciesFeatureType
        __init__(SpeciesFeatureType self, unsigned int level, unsigned int version) -> SpeciesFeatureType
        __init__(SpeciesFeatureType self, unsigned int level) -> SpeciesFeatureType
        __init__(SpeciesFeatureType self) -> SpeciesFeatureType
        __init__(SpeciesFeatureType self, MultiPkgNamespaces multins) -> SpeciesFeatureType
        __init__(SpeciesFeatureType self, SpeciesFeatureType orig) -> SpeciesFeatureType


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            SpeciesFeatureType(SpeciesFeatureType orig)

        Copy constructor for SpeciesFeatureType.

        Parameter 'orig' is the SpeciesFeatureType instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            SpeciesFeatureType(long level      =
        MultiExtension.getDefaultLevel(), long version    =
        MultiExtension.getDefaultVersion(), long pkgVersion =
        MultiExtension.getDefaultPackageVersion())

        Creates a new SpeciesFeatureType object.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            SpeciesFeatureType(MultiPkgNamespaces multins)

        Creates a new SpeciesFeatureType with the given MultiPkgNamespaces
        object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'multins' is the MultiPkgNamespaces object

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_SpeciesFeatureType(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(SpeciesFeatureType self) -> SpeciesFeatureType


        Creates and returns a deep copy of this SpeciesFeatureType object.

        Returns a (deep) copy of this SpeciesFeatureType object.

        """
        return _libsbml.SpeciesFeatureType_clone(self)

    __swig_destroy__ = _libsbml.delete_SpeciesFeatureType
    __del__ = lambda self: None

    def getId(self):
        """
        getId(SpeciesFeatureType self) -> string


        Returns the value of the 'id' attribute of this SpeciesFeatureType.

        Returns the value of the 'id' attribute of this SpeciesFeatureType as
        a string.

        """
        return _libsbml.SpeciesFeatureType_getId(self)


    def isSetId(self):
        """
        isSetId(SpeciesFeatureType self) -> bool


        Returns 'True' if this SpeciesFeatureType's 'id' attribute has been
        set.

        Returns 'True' if this SpeciesFeatureType's 'id' attribute has been
        set, otherwise 'False' is returned.

        """
        return _libsbml.SpeciesFeatureType_isSetId(self)


    def setId(self, id):
        """
        setId(SpeciesFeatureType self, string id) -> int


        Sets the value of the 'id' attribute of this SpeciesFeatureType.

        Parameter 'id' is string value of the 'id' attribute to be set

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.SpeciesFeatureType_setId(self, id)


    def unsetId(self):
        """
        unsetId(SpeciesFeatureType self) -> int


        Unsets the value of the 'id' attribute of this SpeciesFeatureType.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.SpeciesFeatureType_unsetId(self)


    def getName(self):
        """
        getName(SpeciesFeatureType self) -> string


        Returns the value of the 'name' attribute of this SpeciesFeatureType.

        Returns the value of the 'name' attribute of this SpeciesFeatureType
        as a string.

        """
        return _libsbml.SpeciesFeatureType_getName(self)


    def isSetName(self):
        """
        isSetName(SpeciesFeatureType self) -> bool


        Returns 'True' if this SpeciesFeatureType's 'name' attribute has been
        set.

        Returns 'True' if this SpeciesFeatureType's 'name' attribute has been
        set, otherwise 'False' is returned.

        """
        return _libsbml.SpeciesFeatureType_isSetName(self)


    def setName(self, name):
        """
        setName(SpeciesFeatureType self, string name) -> int


        Sets the value of the 'name' attribute of this SpeciesFeatureType.

        Parameter 'name' is string value of the 'name' attribute to be set

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.SpeciesFeatureType_setName(self, name)


    def unsetName(self):
        """
        unsetName(SpeciesFeatureType self) -> int


        Unsets the value of the 'name' attribute of this SpeciesFeatureType.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.SpeciesFeatureType_unsetName(self)


    def getOccur(self):
        """
        getOccur(SpeciesFeatureType self) -> unsigned int


        Returns the value of the 'occur' attribute of this SpeciesFeatureType.

        Returns the value of the 'occur' attribute of this SpeciesFeatureType
        as a longeger.

        """
        return _libsbml.SpeciesFeatureType_getOccur(self)


    def isSetOccur(self):
        """
        isSetOccur(SpeciesFeatureType self) -> bool


        Returns 'True' if this SpeciesFeatureType's 'occur' attribute has been
        set.

        Returns 'True' if this SpeciesFeatureType's 'occur' attribute has been
        set; otherwise, 'False' is returned.

        """
        return _libsbml.SpeciesFeatureType_isSetOccur(self)


    def setOccur(self, occur):
        """
        setOccur(SpeciesFeatureType self, unsigned int occur) -> int


        Sets the value of the 'occur' attribute of this SpeciesFeatureType.

        Parameter 'occur' is long value of the 'occur' attribute to be set

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.SpeciesFeatureType_setOccur(self, occur)


    def unsetOccur(self):
        """
        unsetOccur(SpeciesFeatureType self) -> int


        Unsets the value of the 'occur' attribute of this SpeciesFeatureType.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.SpeciesFeatureType_unsetOccur(self)


    def getListOfPossibleSpeciesFeatureValues(self, *args):
        """
        getListOfPossibleSpeciesFeatureValues(SpeciesFeatureType self) -> ListOfPossibleSpeciesFeatureValues
        getListOfPossibleSpeciesFeatureValues(SpeciesFeatureType self) -> ListOfPossibleSpeciesFeatureValues


        Returns the ListOfPossibleSpeciesFeatureValues in this
        SpeciesFeatureType object.

        Returns the ListOfPossibleSpeciesFeatureValues child of this
        SpeciesFeatureType.

        """
        return _libsbml.SpeciesFeatureType_getListOfPossibleSpeciesFeatureValues(self, *args)


    def getPossibleSpeciesFeatureValue(self, *args):
        """
        getPossibleSpeciesFeatureValue(SpeciesFeatureType self, unsigned int n) -> PossibleSpeciesFeatureValue
        getPossibleSpeciesFeatureValue(SpeciesFeatureType self, unsigned int n) -> PossibleSpeciesFeatureValue
        getPossibleSpeciesFeatureValue(SpeciesFeatureType self, string sid) -> PossibleSpeciesFeatureValue
        getPossibleSpeciesFeatureValue(SpeciesFeatureType self, string sid) -> PossibleSpeciesFeatureValue


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getPossibleSpeciesFeatureValue(long n)

        Get the nth PossibleSpeciesFeatureValue object from the
        ListOfPossibleSpeciesFeatureValues.

        Parameter 'n' is the index number of the PossibleSpeciesFeatureValue
        to get.

        Returns the nth object, or 'None' if the index 'is' out of range.

        See also getNumPossibleSpeciesFeatureValues().

        ______________________________________________________________________
        Method variant with the following signature:

            getPossibleSpeciesFeatureValue(string sid)

        Get the PossibleSpeciesFeatureValue object with the given identifier
        'sid'.

        Parameter 'sid' is a string representing the identifier of the
        PossibleSpeciesFeatureValue to get.

        Returns the object with the given id, or 'None' if no such object
        exists.

        See also getPossibleSpeciesFeatureValue(),
        getNumPossibleSpeciesFeatureValues().

        """
        return _libsbml.SpeciesFeatureType_getPossibleSpeciesFeatureValue(self, *args)


    def addPossibleSpeciesFeatureValue(self, psfv):
        """
        addPossibleSpeciesFeatureValue(SpeciesFeatureType self, PossibleSpeciesFeatureValue psfv) -> int


        Adds a copy the given 'PossibleSpeciesFeatureValue' to this
        SpeciesFeatureType.

        Parameter 'psfv' is the PossibleSpeciesFeatureValue object to add

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.SpeciesFeatureType_addPossibleSpeciesFeatureValue(self, psfv)


    def getNumPossibleSpeciesFeatureValues(self):
        """
        getNumPossibleSpeciesFeatureValues(SpeciesFeatureType self) -> unsigned int


        Get the number of PossibleSpeciesFeatureValue objects in this
        SpeciesFeatureType.

        Returns the number of PossibleSpeciesFeatureValue objects in this
        SpeciesFeatureType

        """
        return _libsbml.SpeciesFeatureType_getNumPossibleSpeciesFeatureValues(self)


    def createPossibleSpeciesFeatureValue(self):
        """
        createPossibleSpeciesFeatureValue(SpeciesFeatureType self) -> PossibleSpeciesFeatureValue


        Creates a new PossibleSpeciesFeatureValue object and adds it to this
        SpeciesFeatureTypes.

        Returns a new PossibleSpeciesFeatureValue object instance

        See also addPossibleSpeciesFeatureValue().

        """
        return _libsbml.SpeciesFeatureType_createPossibleSpeciesFeatureValue(self)


    def removePossibleSpeciesFeatureValue(self, *args):
        """
        removePossibleSpeciesFeatureValue(SpeciesFeatureType self, unsigned int n) -> PossibleSpeciesFeatureValue
        removePossibleSpeciesFeatureValue(SpeciesFeatureType self, string sid) -> PossibleSpeciesFeatureValue


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removePossibleSpeciesFeatureValue(long n)

        Removes the nth PossibleSpeciesFeatureValue object from the
        ListOfPossibleSpeciesFeatureValues.

        Parameter 'n' is the index of the PossibleSpeciesFeatureValue to
        remove.

        Returns the object removed, or 'None' if no such object exists.  Note
        that the caller owns the returned object and is responsible for
        deleting it.

        See also getNumPossibleSpeciesFeatureValues().

        ______________________________________________________________________
        Method variant with the following signature:

            removePossibleSpeciesFeatureValue(string sid)

        Removes the PossibleSpeciesFeatureValue object with the given
        identifier 'sid'.

        Parameter 'sid' is the identifier of the PossibleSpeciesFeatureValue
        to remove.

        Returns the object removed, or 'None' if no such object exists.  Note
        that the caller owns the returned object and is responsible for
        deleting it.

        Returns the PossibleSpeciesFeatureValue removed. As mentioned above,
        the caller owns the returned item.

        """
        return _libsbml.SpeciesFeatureType_removePossibleSpeciesFeatureValue(self, *args)


    def getElementName(self):
        """
        getElementName(SpeciesFeatureType self) -> string


        Returns the XML element name of this object.

        Returns the name of this element, i.e. ''speciesFeatureType'.'

        """
        return _libsbml.SpeciesFeatureType_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(SpeciesFeatureType self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object:
        SBML_MULTI_BINDING_SITE_SPECIES_TYPE.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.SpeciesFeatureType_getTypeCode(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(SpeciesFeatureType self) -> bool


        Predicate returning 'True' if all the required attributes for this
        SpeciesFeatureType object have been set.

        Note: The required attributes for a SpeciesFeatureType object are:

        * 'id'

        * 'occur'

        Returns a boolean value indicating whether all the required attributes
        for this object have been defined.

        """
        return _libsbml.SpeciesFeatureType_hasRequiredAttributes(self)


    def hasRequiredElements(self):
        """
        hasRequiredElements(SpeciesFeatureType self) -> bool


        Predicate returning 'True' if all the required elements for this
        SpeciesFeatureType object have been set.

        Note: A SpeciesFeatureType object has no required subelements.

        Returns a boolean value indicating whether all the required elements
        for this object have been defined.

        """
        return _libsbml.SpeciesFeatureType_hasRequiredElements(self)


    def connectToChild(self):
        """
        connectToChild(SpeciesFeatureType self)


        Internal implementation method.

        """
        return _libsbml.SpeciesFeatureType_connectToChild(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(SpeciesFeatureType self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.SpeciesFeatureType_enablePackageInternal(self, pkgURI, pkgPrefix, flag)

SpeciesFeatureType_swigregister = _libsbml.SpeciesFeatureType_swigregister
SpeciesFeatureType_swigregister(SpeciesFeatureType)

class ListOfSpeciesFeatureTypes(ListOf):
    """

    [SBML 'multi' package]  A list of SpeciesFeatureType objects.

    The ListOfSpeciesFeatureTypes is a container for SpeciesFeatureType
    objects.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    See also SpeciesFeatureType.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfSpeciesFeatureTypes, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfSpeciesFeatureTypes, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ListOfSpeciesFeatureTypes self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ListOfSpeciesFeatureTypes
        __init__(ListOfSpeciesFeatureTypes self, unsigned int level, unsigned int version) -> ListOfSpeciesFeatureTypes
        __init__(ListOfSpeciesFeatureTypes self, unsigned int level) -> ListOfSpeciesFeatureTypes
        __init__(ListOfSpeciesFeatureTypes self) -> ListOfSpeciesFeatureTypes
        __init__(ListOfSpeciesFeatureTypes self, MultiPkgNamespaces multins) -> ListOfSpeciesFeatureTypes


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfSpeciesFeatureTypes(long level      =
        MultiExtension.getDefaultLevel(), long version    =
        MultiExtension.getDefaultVersion(), long pkgVersion =
        MultiExtension.getDefaultPackageVersion())

        Creates a new ListOfSpeciesFeatureTypes object.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfSpeciesFeatureTypes(MultiPkgNamespaces multins)

        Creates a new ListOfSpeciesFeatureTypes with the given
        MultiPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'multins' is the MultiPkgNamespaces object

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_ListOfSpeciesFeatureTypes(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ListOfSpeciesFeatureTypes self) -> ListOfSpeciesFeatureTypes


        Creates and returns a deep copy of this ListOfSpeciesFeatureTypes
        object.

        Returns a (deep) copy of this ListOfSpeciesFeatureTypes object.

        """
        return _libsbml.ListOfSpeciesFeatureTypes_clone(self)


    def get(self, *args):
        """
        get(ListOfSpeciesFeatureTypes self, unsigned int n) -> SpeciesFeatureType
        get(ListOfSpeciesFeatureTypes self, unsigned int n) -> SpeciesFeatureType
        get(ListOfSpeciesFeatureTypes self, string sid) -> SpeciesFeatureType
        get(ListOfSpeciesFeatureTypes self, string sid) -> SpeciesFeatureType


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get the nth SpeciesFeatureType object from the
        ListOfSpeciesFeatureTypes.

        Parameter 'n' is the index number of the SpeciesFeatureType to get.

        Returns the nth object, or 'None' if the index 'is' out of range.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get the SpeciesFeatureType object with the given identifier 'sid'.

        Parameter 'sid' is a string representing the identifier of the
        SpeciesFeatureType to get.

        Returns the object with the given id, or 'None' if no such object
        exists.

        See also get(), size().

        """
        return _libsbml.ListOfSpeciesFeatureTypes_get(self, *args)


    def remove(self, *args):
        """
        remove(ListOfSpeciesFeatureTypes self, unsigned int n) -> SpeciesFeatureType
        remove(ListOfSpeciesFeatureTypes self, string sid) -> SpeciesFeatureType


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth SpeciesFeatureType object from this
        ListOfSpeciesFeatureTypes.

        Parameter 'n' is the index of the SpeciesFeatureType to remove.

        Returns the object removed, or 'None' if no such object exists.  Note
        that the caller owns the returned object and is responsible for
        deleting it.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes the SpeciesFeatureType object with the given identifier 'sid'.

        Parameter 'sid' is the identifier of the SpeciesFeatureType to remove.

        Returns the object removed, or 'None' if no such object exists.  Note
        that the caller owns the returned object and is responsible for
        deleting it.

        """
        return _libsbml.ListOfSpeciesFeatureTypes_remove(self, *args)


    def getElementName(self):
        """
        getElementName(ListOfSpeciesFeatureTypes self) -> string


        Returns the XML element name of this object.

        Returns the name of this element, i.e. ''listOfSpeciesFeatureTypes'.'

        """
        return _libsbml.ListOfSpeciesFeatureTypes_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(ListOfSpeciesFeatureTypes self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object:
        SBML_MULTI_BINDING_SITE_SPECIES_TYPE.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfSpeciesFeatureTypes_getTypeCode(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfSpeciesFeatureTypes self) -> int


        Returns the libSBML type code for the objects contained in this ListOf
        (i.e., Compartment objects, if the list is non-empty).

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for the objects contained in this ListOf
        instance: SBML_COMPARTMENT (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfSpeciesFeatureTypes_getItemTypeCode(self)

    __swig_destroy__ = _libsbml.delete_ListOfSpeciesFeatureTypes
    __del__ = lambda self: None
ListOfSpeciesFeatureTypes_swigregister = _libsbml.ListOfSpeciesFeatureTypes_swigregister
ListOfSpeciesFeatureTypes_swigregister(ListOfSpeciesFeatureTypes)

class SpeciesTypeComponentIndex(SBase):
    """

    [SBML 'multi' package]  Identifies a component within a
    MultiSpeciesType.

    The SpeciesTypeComponentIndex object is a child of MultiSpeciesType,
    and provides a way to identify or index a component within that
    MultiSpeciesType. A SpeciesTypeComponentIndex object can be referenced
    by other class objects, such as InSpeciesTypeBond, OutwardBindingSite,
    SpeciesFeature or SpeciesTypeComponentMapInProduct objects, which need
    to identify a component in a particular MultiSpeciesType.  A
    SpeciesTypeComponentIndex should be unambiguous. For example, a
    SpeciesTypeComponentIndex should not reference a MultiSpeciesType
    which is referenced by two SpeciesTypeInstance objects contained in
    the same MultiSpeciesType object.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SpeciesTypeComponentIndex, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SpeciesTypeComponentIndex, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(SpeciesTypeComponentIndex self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> SpeciesTypeComponentIndex
        __init__(SpeciesTypeComponentIndex self, unsigned int level, unsigned int version) -> SpeciesTypeComponentIndex
        __init__(SpeciesTypeComponentIndex self, unsigned int level) -> SpeciesTypeComponentIndex
        __init__(SpeciesTypeComponentIndex self) -> SpeciesTypeComponentIndex
        __init__(SpeciesTypeComponentIndex self, MultiPkgNamespaces multins) -> SpeciesTypeComponentIndex
        __init__(SpeciesTypeComponentIndex self, SpeciesTypeComponentIndex orig) -> SpeciesTypeComponentIndex


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            SpeciesTypeComponentIndex(SpeciesTypeComponentIndex orig)

        Copy constructor for SpeciesTypeComponentIndex.

        Parameter 'orig' is the SpeciesTypeComponentIndex instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            SpeciesTypeComponentIndex(long level      =
        MultiExtension.getDefaultLevel(), long version    =
        MultiExtension.getDefaultVersion(), long pkgVersion =
        MultiExtension.getDefaultPackageVersion())

        Creates a new SpeciesTypeComponentIndex object.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            SpeciesTypeComponentIndex(MultiPkgNamespaces multins)

        Creates a new SpeciesTypeComponentIndex with the given
        MultiPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'multins' is the MultiPkgNamespaces object

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_SpeciesTypeComponentIndex(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(SpeciesTypeComponentIndex self) -> SpeciesTypeComponentIndex


        Creates and returns a deep copy of this SpeciesTypeComponentIndex
        object.

        Returns a (deep) copy of this SpeciesTypeComponentIndex object.

        """
        return _libsbml.SpeciesTypeComponentIndex_clone(self)

    __swig_destroy__ = _libsbml.delete_SpeciesTypeComponentIndex
    __del__ = lambda self: None

    def getId(self):
        """
        getId(SpeciesTypeComponentIndex self) -> string


        Returns the value of the 'id' attribute of this
        SpeciesTypeComponentIndex.

        Returns the value of the 'id' attribute of this
        SpeciesTypeComponentIndex as a string.

        """
        return _libsbml.SpeciesTypeComponentIndex_getId(self)


    def isSetId(self):
        """
        isSetId(SpeciesTypeComponentIndex self) -> bool


        Returns 'True' if this SpeciesTypeComponentIndex's 'id' attribute has
        been set.

        Returns 'True' if this SpeciesTypeComponentIndex's 'id' attribute has
        been set; otherwise, 'False' is returned.

        """
        return _libsbml.SpeciesTypeComponentIndex_isSetId(self)


    def setId(self, id):
        """
        setId(SpeciesTypeComponentIndex self, string id) -> int


        Sets the value of the 'id' attribute of this
        SpeciesTypeComponentIndex.

        Parameter 'id' is string value of the 'id' attribute to be set

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.SpeciesTypeComponentIndex_setId(self, id)


    def unsetId(self):
        """
        unsetId(SpeciesTypeComponentIndex self) -> int


        Unsets the value of the 'id' attribute of this
        SpeciesTypeComponentIndex.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.SpeciesTypeComponentIndex_unsetId(self)


    def getName(self):
        """
        getName(SpeciesTypeComponentIndex self) -> string


        Returns the value of the 'name' attribute of this
        SpeciesTypeComponentIndex.

        Returns the value of the 'name' attribute of this
        SpeciesTypeComponentIndex as a string.

        """
        return _libsbml.SpeciesTypeComponentIndex_getName(self)


    def isSetName(self):
        """
        isSetName(SpeciesTypeComponentIndex self) -> bool


        Returns 'True' if this SpeciesTypeComponentIndex's 'name' attribute
        has been set.

        Returns 'True' if this SpeciesTypeComponentIndex's 'name' attribute
        has been set; otherwise, 'False' is returned.

        """
        return _libsbml.SpeciesTypeComponentIndex_isSetName(self)


    def setName(self, name):
        """
        setName(SpeciesTypeComponentIndex self, string name) -> int


        Sets the value of the 'name' attribute of this
        SpeciesTypeComponentIndex.

        Parameter 'name' is string value of the 'name' attribute to be set

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.SpeciesTypeComponentIndex_setName(self, name)


    def unsetName(self):
        """
        unsetName(SpeciesTypeComponentIndex self) -> int


        Unsets the value of the 'name' attribute of this
        SpeciesTypeComponentIndex.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.SpeciesTypeComponentIndex_unsetName(self)


    def getComponent(self):
        """
        getComponent(SpeciesTypeComponentIndex self) -> string


        Returns the value of the 'component' attribute of this
        SpeciesTypeComponentIndex.

        Returns the value of the 'component' attribute of this
        SpeciesTypeComponentIndex as a string.

        """
        return _libsbml.SpeciesTypeComponentIndex_getComponent(self)


    def isSetComponent(self):
        """
        isSetComponent(SpeciesTypeComponentIndex self) -> bool


        Returns 'True' if this SpeciesTypeComponentIndex's 'component'
        attribute has been set.

        Returns 'True' if this SpeciesTypeComponentIndex's 'component'
        attribute has been set; otherwise, 'False' is returned.

        """
        return _libsbml.SpeciesTypeComponentIndex_isSetComponent(self)


    def setComponent(self, component):
        """
        setComponent(SpeciesTypeComponentIndex self, string component) -> int


        Sets the value of the 'component' attribute of this
        SpeciesTypeComponentIndex.

        Parameter 'component' is string value of the 'component' attribute to
        be set

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.SpeciesTypeComponentIndex_setComponent(self, component)


    def unsetComponent(self):
        """
        unsetComponent(SpeciesTypeComponentIndex self) -> int


        Unsets the value of the 'component' attribute of this
        SpeciesTypeComponentIndex.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.SpeciesTypeComponentIndex_unsetComponent(self)


    def getIdentifyingParent(self):
        """
        getIdentifyingParent(SpeciesTypeComponentIndex self) -> string


        Returns the value of the 'identifyingParent' attribute of this
        SpeciesTypeComponentIndex.

        Returns the value of the 'identifyingParent' attribute of this
        SpeciesTypeComponentIndex as a string.

        """
        return _libsbml.SpeciesTypeComponentIndex_getIdentifyingParent(self)


    def isSetIdentifyingParent(self):
        """
        isSetIdentifyingParent(SpeciesTypeComponentIndex self) -> bool


        Returns 'True' if this SpeciesTypeComponentIndex's 'identifyingParent'
        attribute has been set.

        Returns 'True' if this SpeciesTypeComponentIndex's 'identifyingParent'
        attribute has been set, otherwise 'False' is returned.

        """
        return _libsbml.SpeciesTypeComponentIndex_isSetIdentifyingParent(self)


    def setIdentifyingParent(self, identifyingParent):
        """
        setIdentifyingParent(SpeciesTypeComponentIndex self, string identifyingParent) -> int


        Sets the value of the 'identifyingParent' attribute of this
        SpeciesTypeComponentIndex.

        Parameter 'identifyingParent' is string value of the
        'identifyingParent' attribute to be set

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.SpeciesTypeComponentIndex_setIdentifyingParent(self, identifyingParent)


    def unsetIdentifyingParent(self):
        """
        unsetIdentifyingParent(SpeciesTypeComponentIndex self) -> int


        Unsets the value of the 'identifyingParent' attribute of this
        SpeciesTypeComponentIndex.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.SpeciesTypeComponentIndex_unsetIdentifyingParent(self)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(SpeciesTypeComponentIndex self, string oldid, string newid)


        Renames all the 'SIdRef' attributes on this element, including any
        found in MathML content (if such exists).

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas, comparing the identifiers to the value of
        'oldid'.  If any matches are found, the matching identifiers are
        replaced with 'newid'.  The method does not descend into child
        elements.

        Parameter 'oldid' is the old identifier Parameter 'newid' is the new
        identifier

        """
        return _libsbml.SpeciesTypeComponentIndex_renameSIdRefs(self, oldid, newid)


    def getElementName(self):
        """
        getElementName(SpeciesTypeComponentIndex self) -> string


        Returns the XML element name of this object.

        Returns the name of this element, i.e. ''speciesTypeComponentIndex'.'

        """
        return _libsbml.SpeciesTypeComponentIndex_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(SpeciesTypeComponentIndex self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object:
        SBML_MULTI_BINDING_SITE_SPECIES_TYPE.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.SpeciesTypeComponentIndex_getTypeCode(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(SpeciesTypeComponentIndex self) -> bool


        Predicate returning 'True' if all the required attributes for this
        SpeciesTypeComponentIndex object have been set.

        Note: The required attributes for a SpeciesTypeComponentIndex object
        are:

        * 'id'

        * 'component'

        Returns a boolean value indicating whether all the required attributes
        for this object have been defined.

        """
        return _libsbml.SpeciesTypeComponentIndex_hasRequiredAttributes(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(SpeciesTypeComponentIndex self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.SpeciesTypeComponentIndex_enablePackageInternal(self, pkgURI, pkgPrefix, flag)

SpeciesTypeComponentIndex_swigregister = _libsbml.SpeciesTypeComponentIndex_swigregister
SpeciesTypeComponentIndex_swigregister(SpeciesTypeComponentIndex)

class ListOfSpeciesTypeComponentIndexes(ListOf):
    """

    [SBML 'multi' package]  A list of SpeciesTypeComponentIndex objects.

    The ListOfSpeciesTypeComponentIndexes is a container for
    SpeciesTypeComponentIndex objects.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    See also SpeciesTypeComponentIndex.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfSpeciesTypeComponentIndexes, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfSpeciesTypeComponentIndexes, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ListOfSpeciesTypeComponentIndexes self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ListOfSpeciesTypeComponentIndexes
        __init__(ListOfSpeciesTypeComponentIndexes self, unsigned int level, unsigned int version) -> ListOfSpeciesTypeComponentIndexes
        __init__(ListOfSpeciesTypeComponentIndexes self, unsigned int level) -> ListOfSpeciesTypeComponentIndexes
        __init__(ListOfSpeciesTypeComponentIndexes self) -> ListOfSpeciesTypeComponentIndexes
        __init__(ListOfSpeciesTypeComponentIndexes self, MultiPkgNamespaces multins) -> ListOfSpeciesTypeComponentIndexes


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfSpeciesTypeComponentIndexes(long level      =
        MultiExtension.getDefaultLevel(), long version    =
        MultiExtension.getDefaultVersion(), long pkgVersion =
        MultiExtension.getDefaultPackageVersion())

        Creates a new ListOfSpeciesTypeComponentIndexes object.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfSpeciesTypeComponentIndexes(MultiPkgNamespaces multins)

        Creates a new ListOfSpeciesTypeComponentIndexes with the given
        MultiPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'multins' is the MultiPkgNamespaces object

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_ListOfSpeciesTypeComponentIndexes(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ListOfSpeciesTypeComponentIndexes self) -> ListOfSpeciesTypeComponentIndexes


        Creates and returns a deep copy of this
        ListOfSpeciesTypeComponentIndexes object.

        Returns a (deep) copy of this ListOfSpeciesTypeComponentIndexes
        object.

        """
        return _libsbml.ListOfSpeciesTypeComponentIndexes_clone(self)


    def get(self, *args):
        """
        get(ListOfSpeciesTypeComponentIndexes self, unsigned int n) -> SpeciesTypeComponentIndex
        get(ListOfSpeciesTypeComponentIndexes self, unsigned int n) -> SpeciesTypeComponentIndex
        get(ListOfSpeciesTypeComponentIndexes self, string sid) -> SpeciesTypeComponentIndex
        get(ListOfSpeciesTypeComponentIndexes self, string sid) -> SpeciesTypeComponentIndex


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get the nth SpeciesTypeComponentIndex object from the
        ListOfSpeciesTypeComponentIndexes.

        Parameter 'n' is the index number of the SpeciesTypeComponentIndex to
        get.

        Returns the nth object, or 'None' if the index 'is' out of range.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get the SpeciesTypeComponentIndex object with the given identifier
        'sid'.

        Parameter 'sid' is a string representing the identifier of the
        SpeciesTypeComponentIndex to get.

        Returns the object with the given id, or 'None' if no such object
        exists.

        See also get()   *, size().

        """
        return _libsbml.ListOfSpeciesTypeComponentIndexes_get(self, *args)


    def remove(self, *args):
        """
        remove(ListOfSpeciesTypeComponentIndexes self, unsigned int n) -> SpeciesTypeComponentIndex
        remove(ListOfSpeciesTypeComponentIndexes self, string sid) -> SpeciesTypeComponentIndex


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth SpeciesTypeComponentIndex object from this
        ListOfSpeciesTypeComponentIndexes.

        Parameter 'n' is the index of the SpeciesTypeComponentIndex to remove.

        Returns the object removed, or 'None' if no such object exists.  Note
        that the caller owns the returned object and is responsible for
        deleting it.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes the SpeciesTypeComponentIndex object with the given identifier
        'sid'.

        Parameter 'sid' is the identifier of the SpeciesTypeComponentIndex to
        remove.

        Returns the object removed, or 'None' if no such object exists.  Note
        that the caller owns the returned object and is responsible for
        deleting it.

        """
        return _libsbml.ListOfSpeciesTypeComponentIndexes_remove(self, *args)


    def getElementName(self):
        """
        getElementName(ListOfSpeciesTypeComponentIndexes self) -> string


        Returns the XML element name of this object.

        Returns the name of this element, i.e.
        ''listOfSpeciesTypeComponentIndexes'.'

        """
        return _libsbml.ListOfSpeciesTypeComponentIndexes_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(ListOfSpeciesTypeComponentIndexes self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object:
        SBML_MULTI_BINDING_SITE_SPECIES_TYPE.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfSpeciesTypeComponentIndexes_getTypeCode(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfSpeciesTypeComponentIndexes self) -> int


        Returns the libSBML type code for the objects contained in this ListOf
        (i.e., Compartment objects, if the list is non-empty).

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for the objects contained in this ListOf
        instance: SBML_COMPARTMENT (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfSpeciesTypeComponentIndexes_getItemTypeCode(self)

    __swig_destroy__ = _libsbml.delete_ListOfSpeciesTypeComponentIndexes
    __del__ = lambda self: None
ListOfSpeciesTypeComponentIndexes_swigregister = _libsbml.ListOfSpeciesTypeComponentIndexes_swigregister
ListOfSpeciesTypeComponentIndexes_swigregister(ListOfSpeciesTypeComponentIndexes)

class SpeciesFeature(SBase):
    """

    [SBML 'multi' package]  Defines a feature of a multi Species.

    Each SpeciesFeature object is a child of the MultiSpeciesPlugin, which
    extends the Species.  Each defines one feature of the parent Species.
    It has three optional attributes, 'id', 'name' and 'component', and
    two required attributes, 'speciesFeatureType' and 'occur', and a
    required child ListOfSpeciesFeatureValues. SpeciesFeature serves to
    define the state of a component in a species by selecting values from
    the ListOfPossibleSpeciesFeatureValues of the referenced
    SpeciesFeatureType. Its 'speciesFeatureType' attribue references the
    particular SpeciesFeatureType of which this Species is an example.
    The 'occur' attribute defines the number of instances of the
    referenced SpeciesFeatureType.  The optional 'component' attribute, of
    type SIdRef, can be used to indicate which component of a Species the
    SpeciesFeature belongs to, and is required when the component cannot
    be identified only based on the speciesFeatureType attribute.  The
    ListOfSpeciesFeatureValues contain one or more SpeciesFeatureValue
    objects -- if more than one, the relationship between them is 'or',
    defining a list of mutually exclusive possibilities.  Each
    SpeciesFeatureValue serves to specify a value for a SpeciesFeature to
    select from the ListOfPossibleSpeciesFeatureValues defined in the
    referenced SpeciesFeatureType.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SpeciesFeature, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SpeciesFeature, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(SpeciesFeature self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> SpeciesFeature
        __init__(SpeciesFeature self, unsigned int level, unsigned int version) -> SpeciesFeature
        __init__(SpeciesFeature self, unsigned int level) -> SpeciesFeature
        __init__(SpeciesFeature self) -> SpeciesFeature
        __init__(SpeciesFeature self, MultiPkgNamespaces multins) -> SpeciesFeature
        __init__(SpeciesFeature self, SpeciesFeature orig) -> SpeciesFeature


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            SpeciesFeature(SpeciesFeature orig)

        Copy constructor for SpeciesFeature.

        Parameter 'orig' is the SpeciesFeature instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            SpeciesFeature(long level      =
        MultiExtension.getDefaultLevel(), long version    =
        MultiExtension.getDefaultVersion(), long pkgVersion =
        MultiExtension.getDefaultPackageVersion())

        Creates a new SpeciesFeature object.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            SpeciesFeature(MultiPkgNamespaces multins)

        Creates a new SpeciesFeature with the given MultiPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'multins' is the MultiPkgNamespaces object

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_SpeciesFeature(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(SpeciesFeature self) -> SpeciesFeature


        Creates and returns a deep copy of this SpeciesFeature object.

        Returns a (deep) copy of this SpeciesFeature object.

        """
        return _libsbml.SpeciesFeature_clone(self)

    __swig_destroy__ = _libsbml.delete_SpeciesFeature
    __del__ = lambda self: None

    def getId(self):
        """
        getId(SpeciesFeature self) -> string


        Returns the value of the 'id' attribute of this SpeciesFeature.

        Returns the value of the 'id' attribute of this SpeciesFeature as a
        string.

        """
        return _libsbml.SpeciesFeature_getId(self)


    def isSetId(self):
        """
        isSetId(SpeciesFeature self) -> bool


        Returns 'True' if this SpeciesFeature's 'id' attribute has been set.

        Returns 'True' if this SpeciesFeature's 'id' attribute has been set;
        otherwise, 'False' is returned.

        """
        return _libsbml.SpeciesFeature_isSetId(self)


    def setId(self, id):
        """
        setId(SpeciesFeature self, string id) -> int


        Sets the value of the 'id' attribute of this SpeciesFeature.

        Parameter 'id' is string value of the 'id' attribute to be set

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.SpeciesFeature_setId(self, id)


    def unsetId(self):
        """
        unsetId(SpeciesFeature self) -> int


        Unsets the value of the 'id' attribute of this SpeciesFeature.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.SpeciesFeature_unsetId(self)


    def getName(self):
        """
        getName(SpeciesFeature self) -> string


        Returns the value of the 'name' attribute of this SpeciesFeature.

        Returns the value of the 'name' attribute of this SpeciesFeature as a
        string.

        """
        return _libsbml.SpeciesFeature_getName(self)


    def isSetName(self):
        """
        isSetName(SpeciesFeature self) -> bool


        Returns 'True' if this SpeciesFeature's 'name' attribute has been set.

        Returns 'True' if this SpeciesFeature's 'name' attribute has been set;
        otherwise, 'False' is returned.

        """
        return _libsbml.SpeciesFeature_isSetName(self)


    def setName(self, name):
        """
        setName(SpeciesFeature self, string name) -> int


        Sets the value of the 'name' attribute of this SpeciesFeature.

        Parameter 'name' is string value of the 'name' attribute to be set

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.SpeciesFeature_setName(self, name)


    def unsetName(self):
        """
        unsetName(SpeciesFeature self) -> int


        Unsets the value of the 'name' attribute of this SpeciesFeature.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.SpeciesFeature_unsetName(self)


    def getSpeciesFeatureType(self):
        """
        getSpeciesFeatureType(SpeciesFeature self) -> string


        Returns the value of the 'speciesFeatureType' attribute of this
        SpeciesFeature.

        Returns the value of the 'speciesFeatureType' attribute of this
        SpeciesFeature as a string.

        """
        return _libsbml.SpeciesFeature_getSpeciesFeatureType(self)


    def isSetSpeciesFeatureType(self):
        """
        isSetSpeciesFeatureType(SpeciesFeature self) -> bool


        Returns 'True' if this SpeciesFeature's 'speciesFeatureType' attribute
        has been set.

        Returns 'True' if this SpeciesFeature's 'speciesFeatureType' attribute
        has been set; otherwise, 'False' is returned.

        """
        return _libsbml.SpeciesFeature_isSetSpeciesFeatureType(self)


    def setSpeciesFeatureType(self, speciesFeatureType):
        """
        setSpeciesFeatureType(SpeciesFeature self, string speciesFeatureType) -> int


        Sets the value of the 'speciesFeatureType' attribute of this
        SpeciesFeature.

        Parameter 'speciesFeatureType' is the new value for the
        'speciesFeatureType' attribute.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.SpeciesFeature_setSpeciesFeatureType(self, speciesFeatureType)


    def unsetSpeciesFeatureType(self):
        """
        unsetSpeciesFeatureType(SpeciesFeature self) -> int


        Unsets the value of the 'speciesFeatureType' attribute of this
        SpeciesFeature.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.SpeciesFeature_unsetSpeciesFeatureType(self)


    def getOccur(self):
        """
        getOccur(SpeciesFeature self) -> unsigned int


        Returns the value of the 'occur' attribute of this SpeciesFeature.

        Returns the value of the 'occur' attribute of this SpeciesFeature as a
        longeger.

        """
        return _libsbml.SpeciesFeature_getOccur(self)


    def isSetOccur(self):
        """
        isSetOccur(SpeciesFeature self) -> bool


        Returns 'True' if this SpeciesFeature's 'occur' attribute has been
        set.

        Returns 'True' if this SpeciesFeature's 'occur' attribute has been
        set; otherwise, 'False' is returned.

        """
        return _libsbml.SpeciesFeature_isSetOccur(self)


    def setOccur(self, occur):
        """
        setOccur(SpeciesFeature self, unsigned int occur) -> int


        Sets the value of the 'occur' attribute of this SpeciesFeature.

        Parameter 'occur' is long value of the 'occur' attribute to be set

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.SpeciesFeature_setOccur(self, occur)


    def unsetOccur(self):
        """
        unsetOccur(SpeciesFeature self) -> int


        Unsets the value of the 'occur' attribute of this SpeciesFeature.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.SpeciesFeature_unsetOccur(self)


    def getComponent(self):
        """
        getComponent(SpeciesFeature self) -> string


        Returns the value of the 'component' attribute of this SpeciesFeature.

        Returns the value of the 'component' attribute of this SpeciesFeature
        as a string.

        """
        return _libsbml.SpeciesFeature_getComponent(self)


    def isSetComponent(self):
        """
        isSetComponent(SpeciesFeature self) -> bool


        Returns 'True' if this SpeciesFeature's 'component' attribute has been
        set.

        Returns 'True' if this SpeciesFeature's 'component' attribute has been
        set; otherwise, 'False' is returned.

        """
        return _libsbml.SpeciesFeature_isSetComponent(self)


    def setComponent(self, component):
        """
        setComponent(SpeciesFeature self, string component) -> int


        Sets the value of the 'component' attribute of this SpeciesFeature.

        Parameter 'component' is the new value of the attribute.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.SpeciesFeature_setComponent(self, component)


    def unsetComponent(self):
        """
        unsetComponent(SpeciesFeature self) -> int


        Unsets the value of the 'component' attribute of this SpeciesFeature.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.SpeciesFeature_unsetComponent(self)


    def getListOfSpeciesFeatureValues(self, *args):
        """
        getListOfSpeciesFeatureValues(SpeciesFeature self) -> ListOfSpeciesFeatureValues
        getListOfSpeciesFeatureValues(SpeciesFeature self) -> ListOfSpeciesFeatureValues


        Returns the ListOfSpeciesFeatureValues in this SpeciesFeature object.

        Returns the ListOfSpeciesFeatureValues child of this SpeciesFeature.

        """
        return _libsbml.SpeciesFeature_getListOfSpeciesFeatureValues(self, *args)


    def getSpeciesFeatureValue(self, *args):
        """
        getSpeciesFeatureValue(SpeciesFeature self, unsigned int n) -> SpeciesFeatureValue
        getSpeciesFeatureValue(SpeciesFeature self, unsigned int n) -> SpeciesFeatureValue
        getSpeciesFeatureValue(SpeciesFeature self, string sid) -> SpeciesFeatureValue
        getSpeciesFeatureValue(SpeciesFeature self, string sid) -> SpeciesFeatureValue


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getSpeciesFeatureValue(long n)

        Get the nth SpeciesFeatureValue object from the
        ListOfSpeciesFeatureValues.

        Parameter 'n' is the index number of the SpeciesFeatureValue to get.

        Returns the nth object, or 'None' if the index 'is' out of range.

        See also getNumSpeciesFeatureValues().

        ______________________________________________________________________
        Method variant with the following signature:

            getSpeciesFeatureValue(string sid)

        Get the SpeciesFeatureValue object with the given identifier 'sid'.

        Parameter 'sid' is a string representing the identifier of the
        SpeciesFeatureValue to get.

        Returns the object with the given id, or 'None' if no such object
        exists.

        See also getSpeciesFeatureValue(), getNumSpeciesFeatureValues().

        """
        return _libsbml.SpeciesFeature_getSpeciesFeatureValue(self, *args)


    def addSpeciesFeatureValue(self, sfv):
        """
        addSpeciesFeatureValue(SpeciesFeature self, SpeciesFeatureValue sfv) -> int


        Adds a copy the given 'SpeciesFeatureValue' to this SpeciesFeature.

        Parameter 'sfv' is the SpeciesFeatureValue object to add

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.SpeciesFeature_addSpeciesFeatureValue(self, sfv)


    def getNumSpeciesFeatureValues(self):
        """
        getNumSpeciesFeatureValues(SpeciesFeature self) -> unsigned int


        Get the number of SpeciesFeatureValue objects in this SpeciesFeature.

        Returns the number of SpeciesFeatureValue objects in this
        SpeciesFeature

        """
        return _libsbml.SpeciesFeature_getNumSpeciesFeatureValues(self)


    def createSpeciesFeatureValue(self):
        """
        createSpeciesFeatureValue(SpeciesFeature self) -> SpeciesFeatureValue


        Creates a new SpeciesFeatureValue object and adds it to this
        SpeciesFeatures ListOfSpeciesFeatureValues.

        Returns a new SpeciesFeatureValue object instance

        See also addSpeciesFeatureValue().

        """
        return _libsbml.SpeciesFeature_createSpeciesFeatureValue(self)


    def removeSpeciesFeatureValue(self, *args):
        """
        removeSpeciesFeatureValue(SpeciesFeature self, unsigned int n) -> SpeciesFeatureValue
        removeSpeciesFeatureValue(SpeciesFeature self, string sid) -> SpeciesFeatureValue


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeSpeciesFeatureValue(long n)

        Removes the nth SpeciesFeatureValue from the
        ListOfSpeciesFeatureValues.

        Parameter 'n' is the index of the SpeciesFeatureValue to remove.

        Returns the object removed, or 'None' if no such object exists.  Note
        that the caller owns the returned object and is responsible for
        deleting it.

        See also getNumSpeciesFeatureValues().

        ______________________________________________________________________
        Method variant with the following signature:

            removeSpeciesFeatureValue(string sid)

        Removes the SpeciesFeatureValue object with the given identifier
        'sid'.

        Parameter 'sid' is the identifier of the SpeciesFeatureValue to
        remove.

        Returns the object removed, or 'None' if no such object exists.  Note
        that the caller owns the returned object and is responsible for
        deleting it.

        """
        return _libsbml.SpeciesFeature_removeSpeciesFeatureValue(self, *args)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(SpeciesFeature self, string oldid, string newid)


        Renames all the 'SIdRef' attributes on this element, including any
        found in MathML content (if such exists).

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas, comparing the identifiers to the value of
        'oldid'.  If any matches are found, the matching identifiers are
        replaced with 'newid'.  The method does not descend into child
        elements.

        Parameter 'oldid' is the old identifier Parameter 'newid' is the new
        identifier

        """
        return _libsbml.SpeciesFeature_renameSIdRefs(self, oldid, newid)


    def getElementName(self):
        """
        getElementName(SpeciesFeature self) -> string


        Returns the XML element name of this object.

        Returns the name of this element, i.e. ''speciesFeature'.'

        """
        return _libsbml.SpeciesFeature_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(SpeciesFeature self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object:
        SBML_MULTI_BINDING_SITE_SPECIES_TYPE.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.SpeciesFeature_getTypeCode(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(SpeciesFeature self) -> bool


        Returns 'True' if this SpeciesFeature object has all the required
        attributes.

        Note: The required attributes for a SpeciesFeature object are:

        * 'speciesFeatureType'

        * 'occur'

        Returns a boolean value indicating whether all the required attributes
        for this object have been defined.

        """
        return _libsbml.SpeciesFeature_hasRequiredAttributes(self)


    def hasRequiredElements(self):
        """
        hasRequiredElements(SpeciesFeature self) -> bool


        Returns 'True' if SpeciesFeature has all the required subelements.

        Note: A SpeciesFeature object has no required subelements.

        Returns a boolean value indicating whether all the required elements
        for this object have been defined.

        """
        return _libsbml.SpeciesFeature_hasRequiredElements(self)


    def connectToChild(self):
        """
        connectToChild(SpeciesFeature self)


        Internal implementation method.

        """
        return _libsbml.SpeciesFeature_connectToChild(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(SpeciesFeature self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.SpeciesFeature_enablePackageInternal(self, pkgURI, pkgPrefix, flag)

SpeciesFeature_swigregister = _libsbml.SpeciesFeature_swigregister
SpeciesFeature_swigregister(SpeciesFeature)

class ListOfSpeciesFeatures(ListOf):
    """

    [SBML 'multi' package]  A list of SpeciesFeature objects.

    The ListOfSpeciesFeatures is a container for SpeciesFeature objects.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    See also SpeciesFeature.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfSpeciesFeatures, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfSpeciesFeatures, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ListOfSpeciesFeatures self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ListOfSpeciesFeatures
        __init__(ListOfSpeciesFeatures self, unsigned int level, unsigned int version) -> ListOfSpeciesFeatures
        __init__(ListOfSpeciesFeatures self, unsigned int level) -> ListOfSpeciesFeatures
        __init__(ListOfSpeciesFeatures self) -> ListOfSpeciesFeatures
        __init__(ListOfSpeciesFeatures self, MultiPkgNamespaces multins) -> ListOfSpeciesFeatures
        __init__(ListOfSpeciesFeatures self, ListOfSpeciesFeatures orig) -> ListOfSpeciesFeatures


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfSpeciesFeatures(ListOfSpeciesFeatures orig)

        Creates and returns a deep copy of this ListOfSpeciesFeatures object

        Parameter 'orig' is the MultiPkgNamespaces object

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfSpeciesFeatures(long level      =
        MultiExtension.getDefaultLevel(), long version    =
        MultiExtension.getDefaultVersion(), long pkgVersion =
        MultiExtension.getDefaultPackageVersion())

        Creates a new ListOfSpeciesFeatures with the given level, version, and
        package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        ListOfSpeciesFeatures

        Parameter 'version' is a long integer, the SBML Version to assign to
        this ListOfSpeciesFeatures

        Parameter 'pkgVersion' is a long integer, the SBML Multi Version to
        assign to this ListOfSpeciesFeatures

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfSpeciesFeatures(MultiPkgNamespaces multins)

        Creates a new ListOfSpeciesFeatures with the given MultiPkgNamespaces
        object.

        Parameter 'multins' is the MultiPkgNamespaces object

        """
        this = _libsbml.new_ListOfSpeciesFeatures(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ListOfSpeciesFeatures self) -> ListOfSpeciesFeatures


        Creates and returns a deep copy of this ListOfSpeciesFeatures object.

        Returns a (deep) copy of this ListOfSpeciesFeatures object.

        """
        return _libsbml.ListOfSpeciesFeatures_clone(self)

    __swig_destroy__ = _libsbml.delete_ListOfSpeciesFeatures
    __del__ = lambda self: None

    def get(self, *args):
        """
        get(ListOfSpeciesFeatures self, unsigned int n) -> SpeciesFeature
        get(ListOfSpeciesFeatures self, unsigned int n) -> SpeciesFeature
        get(ListOfSpeciesFeatures self, string sid) -> SpeciesFeature
        get(ListOfSpeciesFeatures self, string sid) -> SpeciesFeature


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a SpeciesFeature from the ListOfSpeciesFeatures.

        Parameter 'n' is the index number of the SpeciesFeature to get.

        Returns the nth SpeciesFeature in this ListOfSpeciesFeatures. If the
        index 'n' is invalid, 'None' is returned.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a SpeciesFeature from the ListOfSpeciesFeatures based on its
        identifier.

        Parameter 'sid' is a string representing the identifier of the
        SpeciesFeature to get.

        Returns SpeciesFeature in this ListOfSpeciesFeatures with the given id
        or 'None' if no such SpeciesFeature exists.

        See also get()   *, size().

        """
        return _libsbml.ListOfSpeciesFeatures_get(self, *args)


    def remove(self, *args):
        """
        remove(ListOfSpeciesFeatures self, unsigned int n) -> SpeciesFeature
        remove(ListOfSpeciesFeatures self, string sid) -> SpeciesFeature


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth SpeciesFeature from this ListOfSpeciesFeatures and
        returns a pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the SpeciesFeature to remove.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes the SpeciesFeature from this ListOfSpeciesFeatures with the
        given identifier and returns a pointer to it.

        The caller owns the returned item and is responsible for deleting it.
        If none of the items in this list have the identifier 'sid', then
        'None' is returned.

        Parameter 'sid' is the identifier of the SpeciesFeature to remove.

        Returns the SpeciesFeature removed. As mentioned above, the caller
        owns the returned item.

        """
        return _libsbml.ListOfSpeciesFeatures_remove(self, *args)


    def getNumSpeciesFeatures(self):
        """
        getNumSpeciesFeatures(ListOfSpeciesFeatures self) -> unsigned int




        """
        return _libsbml.ListOfSpeciesFeatures_getNumSpeciesFeatures(self)


    def size(self):
        """
        size(ListOfSpeciesFeatures self) -> unsigned int




        """
        return _libsbml.ListOfSpeciesFeatures_size(self)


    def getSubListOfSpeciesFeatures(self, *args):
        """
        getSubListOfSpeciesFeatures(ListOfSpeciesFeatures self, unsigned int n) -> SubListOfSpeciesFeatures
        getSubListOfSpeciesFeatures(ListOfSpeciesFeatures self, unsigned int n) -> SubListOfSpeciesFeatures
        getSubListOfSpeciesFeatures(ListOfSpeciesFeatures self, string sid) -> SubListOfSpeciesFeatures
        getSubListOfSpeciesFeatures(ListOfSpeciesFeatures self, string sid) -> SubListOfSpeciesFeatures


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getSubListOfSpeciesFeatures(long n)

        Get a SubListOfSpeciesFeatures from the ListOfSpeciesFeatures.

        Parameter 'n' is the index number of the SubListOfSpeciesFeatures to
        get.

        Returns the nth SubListOfSpeciesFeatures in this
        ListOfSpeciesFeatures. If the index 'n' is invalid, 'None' is
        returned.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            getSubListOfSpeciesFeatures(string sid)

        Get a SubListOfSpeciesFeatures from the ListOfSpeciesFeatures based on
        its identifier.

        Parameter 'sid' is a string representing the identifier of the
        SubListOfSpeciesFeatures to get.

        Returns SubListOfSpeciesFeatures in this ListOfSpeciesFeatures with
        the given id or 'None' if no such SubListOfSpeciesFeatures exists.

        See also get()   *, size().

        """
        return _libsbml.ListOfSpeciesFeatures_getSubListOfSpeciesFeatures(self, *args)


    def removeSubListOfSpeciesFeatures(self, *args):
        """
        removeSubListOfSpeciesFeatures(ListOfSpeciesFeatures self, unsigned int n) -> SubListOfSpeciesFeatures
        removeSubListOfSpeciesFeatures(ListOfSpeciesFeatures self, string sid) -> SubListOfSpeciesFeatures


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeSubListOfSpeciesFeatures(long n)

        Removes the nth SubListOfSpeciesFeatures from this
        ListOfSpeciesFeatures and returns a pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the SubListOfSpeciesFeatures to remove.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            removeSubListOfSpeciesFeatures(string sid)

        Removes the SubListOfSpeciesFeatures from this ListOfSpeciesFeatures
        with the given identifier and returns a pointer to it.

        The caller owns the returned item and is responsible for deleting it.
        If none of the items in this list have the identifier 'sid', then
        'None' is returned.

        Parameter 'sid' is the identifier of the SubListOfSpeciesFeatures to
        remove.

        Returns the SubListOfSpeciesFeatures removed. As mentioned above, the
        caller owns the returned item.

        """
        return _libsbml.ListOfSpeciesFeatures_removeSubListOfSpeciesFeatures(self, *args)


    def addSubListOfSpeciesFeatures(self, losf):
        """
        addSubListOfSpeciesFeatures(ListOfSpeciesFeatures self, SubListOfSpeciesFeatures losf) -> int




        """
        return _libsbml.ListOfSpeciesFeatures_addSubListOfSpeciesFeatures(self, losf)


    def getNumSubListOfSpeciesFeatures(self):
        """
        getNumSubListOfSpeciesFeatures(ListOfSpeciesFeatures self) -> unsigned int




        """
        return _libsbml.ListOfSpeciesFeatures_getNumSubListOfSpeciesFeatures(self)


    def getElementName(self):
        """
        getElementName(ListOfSpeciesFeatures self) -> string


        Returns the XML element name of this object, which for
        ListOfSpeciesFeatures, is always ''listOfSpeciesFeatures'.'

        Returns the name of this element, i.e. ''listOfSpeciesFeatures'.'

        """
        return _libsbml.ListOfSpeciesFeatures_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(ListOfSpeciesFeatures self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are known as SBML type codes.  In the Python language interface
        for libSBML, the type codes are defined as static integer constants in
        the interface class 'libsbml'.  The names of the type codes all begin
        with the characters 'SBML_.'

        Returns the SBML type code for this object, or SBML_UNKNOWN (default).

        See also getElementName().

        """
        return _libsbml.ListOfSpeciesFeatures_getTypeCode(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfSpeciesFeatures self) -> int


        Returns the libSBML type code for the SBML objects contained in this
        ListOf object

        LibSBML attaches an identifying code to every kind of SBML object.
        These are known as SBML type codes.  In the Python language interface
        for libSBML, the type codes are defined as static integer constants in
        the interface class 'libsbml'.  The names of the type codes all begin
        with the characters 'SBML_.'

        Returns the SBML type code for the objects in this ListOf instance, or
        SBML_UNKNOWN (default).

        See also getElementName().

        """
        return _libsbml.ListOfSpeciesFeatures_getItemTypeCode(self)


    def connectToChild(self):
        """
        connectToChild(ListOfSpeciesFeatures self)


        Internal implementation method.

        """
        return _libsbml.ListOfSpeciesFeatures_connectToChild(self)

ListOfSpeciesFeatures_swigregister = _libsbml.ListOfSpeciesFeatures_swigregister
ListOfSpeciesFeatures_swigregister(ListOfSpeciesFeatures)

class SpeciesTypeComponentMapInProduct(SBase):
    """

    [SBML 'multi' package]  Distinguishes between components in
    reactants versus products.

    The SpeciesTypeComponentMapInProduct object is a child of a
    SpeciesReference (via the MultiSpeciesReferencePlugin) in a Reaction,
    and defines the mapping between a component in a reactant and a
    component in a product. The identifications of a component and the
    SpeciesReference should be sufficient to identify the component in the
    context of a reaction. The attributes 'reactant' and
    'reactantComponent' can identify the component in a reactant, and the
    'productComponent' attribute and the product storing the mapping
    information can identify the component in a product.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SpeciesTypeComponentMapInProduct, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SpeciesTypeComponentMapInProduct, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(SpeciesTypeComponentMapInProduct self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> SpeciesTypeComponentMapInProduct
        __init__(SpeciesTypeComponentMapInProduct self, unsigned int level, unsigned int version) -> SpeciesTypeComponentMapInProduct
        __init__(SpeciesTypeComponentMapInProduct self, unsigned int level) -> SpeciesTypeComponentMapInProduct
        __init__(SpeciesTypeComponentMapInProduct self) -> SpeciesTypeComponentMapInProduct
        __init__(SpeciesTypeComponentMapInProduct self, MultiPkgNamespaces multins) -> SpeciesTypeComponentMapInProduct
        __init__(SpeciesTypeComponentMapInProduct self, SpeciesTypeComponentMapInProduct orig) -> SpeciesTypeComponentMapInProduct


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            SpeciesTypeComponentMapInProduct(SpeciesTypeComponentMapInPro
        duct orig)

        Copy constructor for SpeciesTypeComponentMapInProduct.

        Parameter 'orig' is the SpeciesTypeComponentMapInProduct instance to
        copy.

        ______________________________________________________________________
        Method variant with the following signature:

            SpeciesTypeComponentMapInProduct(long level      =
        MultiExtension.getDefaultLevel(), long version    =
        MultiExtension.getDefaultVersion(), long pkgVersion =
        MultiExtension.getDefaultPackageVersion())

        Creates a new SpeciesTypeComponentMapInProduct object.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            SpeciesTypeComponentMapInProduct(MultiPkgNamespaces multins)

        Creates a new SpeciesTypeComponentMapInProduct with the given
        MultiPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'multins' is the MultiPkgNamespaces object

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_SpeciesTypeComponentMapInProduct(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(SpeciesTypeComponentMapInProduct self) -> SpeciesTypeComponentMapInProduct


        Creates and returns a deep copy of this
        SpeciesTypeComponentMapInProduct object.

        Returns a (deep) copy of this SpeciesTypeComponentMapInProduct object.

        """
        return _libsbml.SpeciesTypeComponentMapInProduct_clone(self)

    __swig_destroy__ = _libsbml.delete_SpeciesTypeComponentMapInProduct
    __del__ = lambda self: None

    def getId(self):
        """
        getId(SpeciesTypeComponentMapInProduct self) -> string


        Returns the value of the 'id' attribute of this
        SpeciesTypeComponentMapInProduct.

        Returns the value of the 'id' attribute of this
        SpeciesTypeComponentMapInProduct as a string.

        """
        return _libsbml.SpeciesTypeComponentMapInProduct_getId(self)


    def isSetId(self):
        """
        isSetId(SpeciesTypeComponentMapInProduct self) -> bool


        Returns 'True' if this SpeciesTypeComponentMapInProduct's 'id'
        attribute has been set.

        Returns 'True' if this SpeciesTypeComponentMapInProduct's 'id'
        attribute has been set, otherwise 'False' is returned.

        """
        return _libsbml.SpeciesTypeComponentMapInProduct_isSetId(self)


    def setId(self, id):
        """
        setId(SpeciesTypeComponentMapInProduct self, string id) -> int


        Sets the value of the 'id' attribute of this
        SpeciesTypeComponentMapInProduct.

        Parameter 'id' is string value of the 'id' attribute to be set

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.SpeciesTypeComponentMapInProduct_setId(self, id)


    def unsetId(self):
        """
        unsetId(SpeciesTypeComponentMapInProduct self) -> int


        Unsets the value of the 'id' attribute of this
        SpeciesTypeComponentMapInProduct.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.SpeciesTypeComponentMapInProduct_unsetId(self)


    def getName(self):
        """
        getName(SpeciesTypeComponentMapInProduct self) -> string


        Returns the value of the 'name' attribute of this
        SpeciesTypeComponentMapInProduct.

        Returns the value of the 'name' attribute of this
        SpeciesTypeComponentMapInProduct as a string.

        """
        return _libsbml.SpeciesTypeComponentMapInProduct_getName(self)


    def isSetName(self):
        """
        isSetName(SpeciesTypeComponentMapInProduct self) -> bool


        Returns 'True' if this SpeciesTypeComponentMapInProduct's 'name'
        attribute has been set.

        Returns 'True' if this SpeciesTypeComponentMapInProduct's 'name'
        attribute has been set, otherwise 'False' is returned.

        """
        return _libsbml.SpeciesTypeComponentMapInProduct_isSetName(self)


    def setName(self, name):
        """
        setName(SpeciesTypeComponentMapInProduct self, string name) -> int


        Sets the value of the 'name' attribute of this
        SpeciesTypeComponentMapInProduct.

        Parameter 'name' is string value of the 'name' attribute to be set

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.SpeciesTypeComponentMapInProduct_setName(self, name)


    def unsetName(self):
        """
        unsetName(SpeciesTypeComponentMapInProduct self) -> int


        Unsets the value of the 'name' attribute of this
        SpeciesTypeComponentMapInProduct.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.SpeciesTypeComponentMapInProduct_unsetName(self)


    def getReactant(self):
        """
        getReactant(SpeciesTypeComponentMapInProduct self) -> string


        Returns the value of the 'reactant' attribute of this
        SpeciesTypeComponentMapInProduct.

        Returns the value of the 'reactant' attribute of this
        SpeciesTypeComponentMapInProduct as a string.

        """
        return _libsbml.SpeciesTypeComponentMapInProduct_getReactant(self)


    def isSetReactant(self):
        """
        isSetReactant(SpeciesTypeComponentMapInProduct self) -> bool


        Returns 'True' if this SpeciesTypeComponentMapInProduct's 'reactant'
        attribute has been set.

        Returns 'True' if this SpeciesTypeComponentMapInProduct's 'reactant'
        attribute has been set; otherwise, 'False' is returned.

        """
        return _libsbml.SpeciesTypeComponentMapInProduct_isSetReactant(self)


    def setReactant(self, reactant):
        """
        setReactant(SpeciesTypeComponentMapInProduct self, string reactant) -> int


        Sets the value of the 'reactant' attribute of this
        SpeciesTypeComponentMapInProduct.

        Parameter 'reactant' is string value of the 'reactant' attribute to be
        set

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.SpeciesTypeComponentMapInProduct_setReactant(self, reactant)


    def unsetReactant(self):
        """
        unsetReactant(SpeciesTypeComponentMapInProduct self) -> int


        Unsets the value of the 'reactant' attribute of this
        SpeciesTypeComponentMapInProduct.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.SpeciesTypeComponentMapInProduct_unsetReactant(self)


    def getReactantComponent(self):
        """
        getReactantComponent(SpeciesTypeComponentMapInProduct self) -> string


        Returns the value of the 'reactantComponent' attribute of this
        SpeciesTypeComponentMapInProduct.

        Returns the value of the 'reactantComponent' attribute of this
        SpeciesTypeComponentMapInProduct as a string.

        """
        return _libsbml.SpeciesTypeComponentMapInProduct_getReactantComponent(self)


    def isSetReactantComponent(self):
        """
        isSetReactantComponent(SpeciesTypeComponentMapInProduct self) -> bool


        Returns 'True' if this SpeciesTypeComponentMapInProduct's
        'reactantComponent' attribute has been set.

        Returns 'True' if this SpeciesTypeComponentMapInProduct's
        'reactantComponent' attribute has been set; otherwise, 'False' is
        returned.

        """
        return _libsbml.SpeciesTypeComponentMapInProduct_isSetReactantComponent(self)


    def setReactantComponent(self, reactantComponent):
        """
        setReactantComponent(SpeciesTypeComponentMapInProduct self, string reactantComponent) -> int


        Sets the value of the 'reactantComponent' attribute of this
        SpeciesTypeComponentMapInProduct.

        Parameter 'reactantComponent' is string value of the
        'reactantComponent' attribute to be set

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.SpeciesTypeComponentMapInProduct_setReactantComponent(self, reactantComponent)


    def unsetReactantComponent(self):
        """
        unsetReactantComponent(SpeciesTypeComponentMapInProduct self) -> int


        Unsets the value of the 'reactantComponent' attribute of this
        SpeciesTypeComponentMapInProduct.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.SpeciesTypeComponentMapInProduct_unsetReactantComponent(self)


    def getProductComponent(self):
        """
        getProductComponent(SpeciesTypeComponentMapInProduct self) -> string


        Returns the value of the 'productComponent' attribute of this
        SpeciesTypeComponentMapInProduct.

        Returns the value of the 'productComponent' attribute of this
        SpeciesTypeComponentMapInProduct as a string.

        """
        return _libsbml.SpeciesTypeComponentMapInProduct_getProductComponent(self)


    def isSetProductComponent(self):
        """
        isSetProductComponent(SpeciesTypeComponentMapInProduct self) -> bool


        Returns 'True' if this SpeciesTypeComponentMapInProduct's
        'productComponent' attribute has been set.

        Returns 'True' if this SpeciesTypeComponentMapInProduct's
        'productComponent' attribute has been set, otherwise 'False' is
        returned.

        """
        return _libsbml.SpeciesTypeComponentMapInProduct_isSetProductComponent(self)


    def setProductComponent(self, productComponent):
        """
        setProductComponent(SpeciesTypeComponentMapInProduct self, string productComponent) -> int


        Sets the value of the 'productComponent' attribute of this
        SpeciesTypeComponentMapInProduct.

        Parameter 'productComponent' is the new value of the attribute.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.SpeciesTypeComponentMapInProduct_setProductComponent(self, productComponent)


    def unsetProductComponent(self):
        """
        unsetProductComponent(SpeciesTypeComponentMapInProduct self) -> int


        Unsets the value of the 'productComponent' attribute of this
        SpeciesTypeComponentMapInProduct.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.SpeciesTypeComponentMapInProduct_unsetProductComponent(self)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(SpeciesTypeComponentMapInProduct self, string oldid, string newid)


        Renames all the 'SIdRef' attributes on this element, including any
        found in MathML content (if such exists).

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas, comparing the identifiers to the value of
        'oldid'.  If any matches are found, the matching identifiers are
        replaced with 'newid'.  The method does not descend into child
        elements.

        Parameter 'oldid' is the old identifier Parameter 'newid' is the new
        identifier

        """
        return _libsbml.SpeciesTypeComponentMapInProduct_renameSIdRefs(self, oldid, newid)


    def getElementName(self):
        """
        getElementName(SpeciesTypeComponentMapInProduct self) -> string


        Returns the XML element name of this object.

        Returns the name of this element, i.e.
        ''speciesTypeComponentMapInProduct'.'

        """
        return _libsbml.SpeciesTypeComponentMapInProduct_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(SpeciesTypeComponentMapInProduct self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object:
        SBML_MULTI_BINDING_SITE_SPECIES_TYPE.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.SpeciesTypeComponentMapInProduct_getTypeCode(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(SpeciesTypeComponentMapInProduct self) -> bool


        Predicate returning 'True' if all the required attributes for this
        SpeciesTypeComponentMapInProduct object have been set.

        Note: The required attributes for a SpeciesTypeComponentMapInProduct
        object are:

        * 'reactant'

        * 'reactantComponent'

        * 'productComponent'

        Returns a boolean value indicating whether all the required attributes
        for this object have been defined.

        """
        return _libsbml.SpeciesTypeComponentMapInProduct_hasRequiredAttributes(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(SpeciesTypeComponentMapInProduct self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.SpeciesTypeComponentMapInProduct_enablePackageInternal(self, pkgURI, pkgPrefix, flag)

SpeciesTypeComponentMapInProduct_swigregister = _libsbml.SpeciesTypeComponentMapInProduct_swigregister
SpeciesTypeComponentMapInProduct_swigregister(SpeciesTypeComponentMapInProduct)

class ListOfSpeciesTypeComponentMapInProducts(ListOf):
    """

    [SBML 'multi' package]  A list of SpeciesTypeComponentMapInProduct
    objects.

    The ListOfSpeciesTypeComponentMapInProducts is a container for
    SpeciesTypeComponentMapInProduct objects.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    See also SpeciesTypeComponentMapInProduct.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfSpeciesTypeComponentMapInProducts, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfSpeciesTypeComponentMapInProducts, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ListOfSpeciesTypeComponentMapInProducts self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ListOfSpeciesTypeComponentMapInProducts
        __init__(ListOfSpeciesTypeComponentMapInProducts self, unsigned int level, unsigned int version) -> ListOfSpeciesTypeComponentMapInProducts
        __init__(ListOfSpeciesTypeComponentMapInProducts self, unsigned int level) -> ListOfSpeciesTypeComponentMapInProducts
        __init__(ListOfSpeciesTypeComponentMapInProducts self) -> ListOfSpeciesTypeComponentMapInProducts
        __init__(ListOfSpeciesTypeComponentMapInProducts self, MultiPkgNamespaces multins) -> ListOfSpeciesTypeComponentMapInProducts


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfSpeciesTypeComponentMapInProducts(long level      =
        MultiExtension.getDefaultLevel(), long version    =
        MultiExtension.getDefaultVersion(), long pkgVersion =
        MultiExtension.getDefaultPackageVersion())

        Creates a new ListOfSpeciesTypeComponentMapInProducts object.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfSpeciesTypeComponentMapInProducts(MultiPkgNamespaces
        multins)

        Creates a new ListOfSpeciesTypeComponentMapInProducts with the given
        MultiPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'multins' is the MultiPkgNamespaces object

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_ListOfSpeciesTypeComponentMapInProducts(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ListOfSpeciesTypeComponentMapInProducts self) -> ListOfSpeciesTypeComponentMapInProducts


        Creates and returns a deep copy of this
        ListOfSpeciesTypeComponentMapInProducts object.

        Returns a (deep) copy of this ListOfSpeciesTypeComponentMapInProducts
        object.

        """
        return _libsbml.ListOfSpeciesTypeComponentMapInProducts_clone(self)


    def get(self, *args):
        """
        get(ListOfSpeciesTypeComponentMapInProducts self, unsigned int n) -> SpeciesTypeComponentMapInProduct
        get(ListOfSpeciesTypeComponentMapInProducts self, unsigned int n) -> SpeciesTypeComponentMapInProduct
        get(ListOfSpeciesTypeComponentMapInProducts self, string sid) -> SpeciesTypeComponentMapInProduct
        get(ListOfSpeciesTypeComponentMapInProducts self, string sid) -> SpeciesTypeComponentMapInProduct


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get the nth SpeciesTypeComponentMapInProduct object from the
        ListOfSpeciesTypeComponentMapInProducts.

        Parameter 'n' is the index number of the
        SpeciesTypeComponentMapInProduct to get.

        Returns the nth object, or 'None' if the index 'is' out of range.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get the SpeciesTypeComponentMapInProduct object with the given
        identifier 'sid'.

        Parameter 'sid' is a string representing the identifier of the
        SpeciesTypeComponentMapInProduct to get.

        Returns the object with the given id, or 'None' if no such object
        exists.

        See also get(), size().

        """
        return _libsbml.ListOfSpeciesTypeComponentMapInProducts_get(self, *args)


    def remove(self, *args):
        """
        remove(ListOfSpeciesTypeComponentMapInProducts self, unsigned int n) -> SpeciesTypeComponentMapInProduct
        remove(ListOfSpeciesTypeComponentMapInProducts self, string sid) -> SpeciesTypeComponentMapInProduct


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth SpeciesTypeComponentMapInProduct object from this
        ListOfSpeciesTypeComponentMapInProducts.

        Parameter 'n' is the index of the SpeciesTypeComponentMapInProduct to
        remove.

        Returns the object removed, or 'None' if no such object exists.  Note
        that the caller owns the returned object and is responsible for
        deleting it.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes the SpeciesTypeComponentMapInProduct object with the given
        identifier 'sid'.

        Parameter 'sid' is the identifier of the
        SpeciesTypeComponentMapInProduct to remove.

        Returns the object removed, or 'None' if no such object exists.  Note
        that the caller owns the returned object and is responsible for
        deleting it.

        """
        return _libsbml.ListOfSpeciesTypeComponentMapInProducts_remove(self, *args)


    def getElementName(self):
        """
        getElementName(ListOfSpeciesTypeComponentMapInProducts self) -> string


        Returns the XML element name of this object.

        Returns the name of this element, i.e.
        ''listOfSpeciesTypeComponentMapInProducts'.'

        """
        return _libsbml.ListOfSpeciesTypeComponentMapInProducts_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(ListOfSpeciesTypeComponentMapInProducts self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object:
        SBML_MULTI_BINDING_SITE_SPECIES_TYPE.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfSpeciesTypeComponentMapInProducts_getTypeCode(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfSpeciesTypeComponentMapInProducts self) -> int


        Returns the libSBML type code for the objects contained in this ListOf
        (i.e., Compartment objects, if the list is non-empty).

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for the objects contained in this ListOf
        instance: SBML_COMPARTMENT (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfSpeciesTypeComponentMapInProducts_getItemTypeCode(self)

    __swig_destroy__ = _libsbml.delete_ListOfSpeciesTypeComponentMapInProducts
    __del__ = lambda self: None
ListOfSpeciesTypeComponentMapInProducts_swigregister = _libsbml.ListOfSpeciesTypeComponentMapInProducts_swigregister
ListOfSpeciesTypeComponentMapInProducts_swigregister(ListOfSpeciesTypeComponentMapInProducts)

MULTI_RELATION_AND = _libsbml.MULTI_RELATION_AND
MULTI_RELATION_OR = _libsbml.MULTI_RELATION_OR
MULTI_RELATION_NOT = _libsbml.MULTI_RELATION_NOT
MULTI_RELATION_UNKNOWN = _libsbml.MULTI_RELATION_UNKNOWN
class SubListOfSpeciesFeatures(ListOf):
    """

    [SBML 'multi' package]  Defines a set of SpeciesFeature objects.

    The SubListOfSpeciesFeatures object is an optional child of the
    ListOfSpeciesFeatures list child of the extended Species (via the
    MultiSpeciesPlugin object).  Listed alongside its sibling
    SpeciesFeature objects, it allows the user to define a set of two or
    more SpeciesFeature elements that have a logical relationship with
    each other.  This relationship is defined by the 'relation' attribute,
    which is an enumeration of values representing 'and', 'or', 'not'.
    (An 'unknown' option is provided here for incomplete models, but
    cannot be used in a valid SBML document.)  The following constants
    represent the values: MULTI_RELATION_AND, MULTI_RELATION_OR,
    MULTI_RELATION_NOT, and MULTI_RELATION_UNKNOWN. If any SpeciesFeature
    involved in a SubListOfSpeciesFeatures references a SpeciesFeatureType
    with an 'occur' attribute greater than 1, the SubListOfSpeciesFeatures
    can only have the value 'and' for its relation attribute.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SubListOfSpeciesFeatures, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SubListOfSpeciesFeatures, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(SubListOfSpeciesFeatures self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> SubListOfSpeciesFeatures
        __init__(SubListOfSpeciesFeatures self, unsigned int level, unsigned int version) -> SubListOfSpeciesFeatures
        __init__(SubListOfSpeciesFeatures self, unsigned int level) -> SubListOfSpeciesFeatures
        __init__(SubListOfSpeciesFeatures self) -> SubListOfSpeciesFeatures
        __init__(SubListOfSpeciesFeatures self, MultiPkgNamespaces multins) -> SubListOfSpeciesFeatures
        __init__(SubListOfSpeciesFeatures self, SubListOfSpeciesFeatures orig) -> SubListOfSpeciesFeatures


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            SubListOfSpeciesFeatures(SubListOfSpeciesFeatures orig)

        Creates and return a copy of SubListOfSpeciesFeatures.

        Parameter 'orig' is this SubListOfSpeciesFeatures object

        ______________________________________________________________________
        Method variant with the following signature:

            SubListOfSpeciesFeatures(long level      =
        MultiExtension.getDefaultLevel(), long version    =
        MultiExtension.getDefaultVersion(), long pkgVersion =
        MultiExtension.getDefaultPackageVersion())

        Creates a new SubListOfSpeciesFeatures object.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            SubListOfSpeciesFeatures(MultiPkgNamespaces multins)

        Creates a new SubListOfSpeciesFeatures with the given
        MultiPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'multins' is the MultiPkgNamespaces object

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_SubListOfSpeciesFeatures(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(SubListOfSpeciesFeatures self) -> SubListOfSpeciesFeatures


        Creates and returns a deep copy of this SubListOfSpeciesFeatures
        object.

        Returns a (deep) copy of this SubListOfSpeciesFeatures object.

        """
        return _libsbml.SubListOfSpeciesFeatures_clone(self)

    __swig_destroy__ = _libsbml.delete_SubListOfSpeciesFeatures
    __del__ = lambda self: None

    def getId(self):
        """
        getId(SubListOfSpeciesFeatures self) -> string


        Returns the value of the 'id' attribute of this
        SubListOfSpeciesFeatures.

        Returns the value of the 'id' attribute of this
        SubListOfSpeciesFeatures as a string.

        """
        return _libsbml.SubListOfSpeciesFeatures_getId(self)


    def isSetId(self):
        """
        isSetId(SubListOfSpeciesFeatures self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        SubListOfSpeciesFeatures's 'id' attribute has been set.

        Returns 'True' if this SubListOfSpeciesFeatures's 'id' attribute has
        been set, otherwise 'False' is returned.

        """
        return _libsbml.SubListOfSpeciesFeatures_isSetId(self)


    def setId(self, id):
        """
        setId(SubListOfSpeciesFeatures self, string id) -> int


        Sets the value of the 'id' attribute of this SubListOfSpeciesFeatures.

        Parameter 'id' is string value of the 'id' attribute to be set

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.SubListOfSpeciesFeatures_setId(self, id)


    def unsetId(self):
        """
        unsetId(SubListOfSpeciesFeatures self) -> int


        Unsets the value of the 'id' attribute of this
        SubListOfSpeciesFeatures.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.SubListOfSpeciesFeatures_unsetId(self)


    def getName(self):
        """
        getName(SubListOfSpeciesFeatures self) -> string


        Returns the value of the 'name' attribute of this
        SubListOfSpeciesFeatures.

        Returns the value of the 'name' attribute of this
        SubListOfSpeciesFeatures as a string.

        """
        return _libsbml.SubListOfSpeciesFeatures_getName(self)


    def isSetName(self):
        """
        isSetName(SubListOfSpeciesFeatures self) -> bool


        Returns 'True' if this SubListOfSpeciesFeatures's 'name' attribute has
        been set.

        Returns 'True' if this SubListOfSpeciesFeatures' 'name' attribute has
        been set, otherwise 'False' is returned.

        """
        return _libsbml.SubListOfSpeciesFeatures_isSetName(self)


    def setName(self, name):
        """
        setName(SubListOfSpeciesFeatures self, string name) -> int


        Sets the value of the 'name' attribute of this
        SubListOfSpeciesFeatures.

        Parameter 'name' is the new value for the attribute.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.SubListOfSpeciesFeatures_setName(self, name)


    def unsetName(self):
        """
        unsetName(SubListOfSpeciesFeatures self) -> int


        Unsets the value of the 'name' attribute of this
        SubListOfSpeciesFeatures.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.SubListOfSpeciesFeatures_unsetName(self)


    def getComponent(self):
        """
        getComponent(SubListOfSpeciesFeatures self) -> string


        Returns the value of the 'component' attribute of this
        SubListOfSpeciesFeatures.

        Returns the value of the 'component' attribute of this
        SubListOfSpeciesFeatures as a string.

        """
        return _libsbml.SubListOfSpeciesFeatures_getComponent(self)


    def isSetComponent(self):
        """
        isSetComponent(SubListOfSpeciesFeatures self) -> bool


        Returns 'True' if this SubListOfSpeciesFeatures's 'component'
        attribute has been set.

        Returns 'True' if this SubListOfSpeciesFeatures's 'component'
        attribute has been set; otherwise, 'False' is returned.

        """
        return _libsbml.SubListOfSpeciesFeatures_isSetComponent(self)


    def setComponent(self, component):
        """
        setComponent(SubListOfSpeciesFeatures self, string component) -> int


        Sets the value of the 'component' attribute of this
        SubListOfSpeciesFeatures.

        Parameter 'component' is the new value for the attribute.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.SubListOfSpeciesFeatures_setComponent(self, component)


    def unsetComponent(self):
        """
        unsetComponent(SubListOfSpeciesFeatures self) -> int


        Unsets the value of the 'component' attribute of this
        SubListOfSpeciesFeatures.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.SubListOfSpeciesFeatures_unsetComponent(self)


    def createSpeciesFeature(self):
        """
        createSpeciesFeature(SubListOfSpeciesFeatures self) -> SpeciesFeature


        Creates a new SpeciesFeature object and adds it to this
        SubListOfSpeciesFeatures object.

        Returns the newly created SpeciesFeature object.

        """
        return _libsbml.SubListOfSpeciesFeatures_createSpeciesFeature(self)


    def get(self, *args):
        """
        get(SubListOfSpeciesFeatures self, unsigned int n) -> SpeciesFeature
        get(SubListOfSpeciesFeatures self, unsigned int n) -> SpeciesFeature
        get(SubListOfSpeciesFeatures self, string sid) -> SpeciesFeature
        get(SubListOfSpeciesFeatures self, string sid) -> SpeciesFeature


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get the nth SpeciesFeature object from the SubListOfSpeciesFeatures.

        Parameter 'n' is the index number of the SpeciesFeature to get.

        Returns the nth object, or 'None' if the index 'is' out of range.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get the SpeciesFeature object with the given identifier 'sid'.

        Parameter 'sid' is a string representing the identifier of the
        SpeciesFeature to get.

        Returns the object with the given id, or 'None' if no such object
        exists.

        See also get()   *, size().

        """
        return _libsbml.SubListOfSpeciesFeatures_get(self, *args)


    def remove(self, *args):
        """
        remove(SubListOfSpeciesFeatures self, unsigned int n) -> SpeciesFeature
        remove(SubListOfSpeciesFeatures self, string sid) -> SpeciesFeature


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth SpeciesFeature object from this
        SubListOfSpeciesFeatures.

        Parameter 'n' is the index of the SpeciesFeature to remove.

        Returns the object removed, or 'None' if no such object exists.  Note
        that the caller owns the returned object and is responsible for
        deleting it.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes the SpeciesFeature object with the given identifier 'sid'.

        Parameter 'sid' is the identifier of the SpeciesFeature to remove.

        Returns the object removed, or 'None' if no such object exists.  Note
        that the caller owns the returned object and is responsible for
        deleting it.

        """
        return _libsbml.SubListOfSpeciesFeatures_remove(self, *args)


    def getRelation(self):
        """
        getRelation(SubListOfSpeciesFeatures self) -> Relation_t


        Returns the value of the 'relation' attribute of this
        SubListOfSpeciesFeatures.

        Returns the value of the 'relation' attribute of this
        SubListOfSpeciesFeatures as a FIX ME.

        """
        return _libsbml.SubListOfSpeciesFeatures_getRelation(self)


    def isSetRelation(self):
        """
        isSetRelation(SubListOfSpeciesFeatures self) -> bool


        Returns 'True' if this SubListOfSpeciesFeatures's 'relation' attribute
        has been set.

        Returns 'True' if this SubListOfSpeciesFeatures's 'relation' attribute
        has been set; otherwise, 'False' is returned.

        """
        return _libsbml.SubListOfSpeciesFeatures_isSetRelation(self)


    def setRelation(self, *args):
        """
        setRelation(SubListOfSpeciesFeatures self, Relation_t relation) -> int
        setRelation(SubListOfSpeciesFeatures self, string relation) -> int


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            setRelation(Relation_t relation)

        Sets the value of the 'relation' attribute of this
        SubListOfSpeciesFeatures.

        Parameter 'relation' is FIX ME value of the 'relation' attribute to be
        set

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        ______________________________________________________________________
        Method variant with the following signature:

            setRelation(string relation)

        Sets the value of the 'relation' attribute of this
        SubListOfSpeciesFeatures.

        Parameter 'relation' is string& of the 'relation' attribute to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        The attribute 'relation' on a SubListOfSpeciesFeatures object is used
        to define the logic relationship among its children.  If any
        SpeciesFeature involved in a SubListOfSpeciesFeatures references a
        SpeciesFeatureType with  occur > 1, the SubListOfSpeciesFeatures can
        only have the value 'and' for its relation attribute.

        In the SBML Level 3 Version 1 Multi specification, the following are
        the allowable values for 'relation':

        * ''and',' means that the species features all apply.

        * ''or',' means that at least one of the species features apply.

        * ''not',' means that the species feature must not apply.

        """
        return _libsbml.SubListOfSpeciesFeatures_setRelation(self, *args)


    def unsetRelation(self):
        """
        unsetRelation(SubListOfSpeciesFeatures self) -> int


        Unsets the value of the 'relation' attribute of this
        SubListOfSpeciesFeatures.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.SubListOfSpeciesFeatures_unsetRelation(self)


    def getElementName(self):
        """
        getElementName(SubListOfSpeciesFeatures self) -> string


        Returns the XML element name of this object.

        Returns the name of this element, i.e. ''subListOfSpeciesFeatures'.'

        """
        return _libsbml.SubListOfSpeciesFeatures_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(SubListOfSpeciesFeatures self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object:
        SBML_MULTI_BINDING_SITE_SPECIES_TYPE.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.SubListOfSpeciesFeatures_getTypeCode(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(SubListOfSpeciesFeatures self) -> int


        Returns the libSBML type code for the objects contained in this ListOf
        (i.e., Compartment objects, if the list is non-empty).

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for the objects contained in this ListOf
        instance: SBML_COMPARTMENT (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.SubListOfSpeciesFeatures_getItemTypeCode(self)


    def connectToChild(self):
        """
        connectToChild(SubListOfSpeciesFeatures self)


        Internal implementation method.

        """
        return _libsbml.SubListOfSpeciesFeatures_connectToChild(self)


    def getNumSpeciesFeatures(self):
        """
        getNumSpeciesFeatures(SubListOfSpeciesFeatures self) -> unsigned int


        Returns the number of SpeciesFeature objects contained in this
        SubListOfSpeciesFeatures.

        A ListOfSpeciesFeature can contain either speciesFeature elements or a
        SubListOfSpeciesFeatures (which is derived from ListOf), which itself
        contains SpeciesFeature elements. The sublist also has a couple of
        attributes which describe the relationship of the members of the
        sublist to each other and their parent ListOfSpeciesFeatures.  Here is
        a sample of the XML:

          <multi:listOfSpeciesFeatures>
            <multi:speciesFeature multi:speciesFeatureType='sftP' multi:occur='1'>
              <snip/>
            </multi:speciesFeature>
            <multi:subListOfSpeciesFeatures multi:component='stY1' multi:relation='not'>
              <multi:speciesFeature multi:speciesFeatureType='sftYP1' multi:occur='1'>
                <snip/>
              </multi:speciesFeature>
              <multi:speciesFeature multi:speciesFeatureType='sftYP2' multi:occur='1'>
                <multi:listOfSpeciesFeatureValues>
                  <multi:speciesFeatureValue multi:value='yp1v1b'/>
                </multi:listOfSpeciesFeatureValues>
              </multi:speciesFeature>
            </multi:subListOfSpeciesFeatures>
          </multi:listOfSpeciesFeatures>

        Returns a count of the SpeciesFeature objects.

        """
        return _libsbml.SubListOfSpeciesFeatures_getNumSpeciesFeatures(self)

SubListOfSpeciesFeatures_swigregister = _libsbml.SubListOfSpeciesFeatures_swigregister
SubListOfSpeciesFeatures_swigregister(SubListOfSpeciesFeatures)


def Relation_toString(r):
    """
    Relation_toString(Relation_t r) -> char const *


    Returns the string version of the provided Relation_t enumeration.

    Parameter 'r' is the Relation_t enumeration value to convert.

    Returns A string corresponding to the given type: 'and', 'or', 'not',
    or 'None' if the value is MULTI_RELATION_UNKNOWN or another invalid
    enumeration value.

    Note: The string returned by this function is a pointer to a string
    literal defined in the libSBML library, and may not be modified or
    deleted.

    """
    return _libsbml.Relation_toString(r)

def Relation_fromString(code):
    """
    Relation_fromString(char const * code) -> Relation_t


    Returns the Relation_t enumeration corresponding to the given string
    or MULTI_RELATION_UNKNOWN if there is no such match.

    Parameter 'code' is the string to convert to a Relation_t.

    Returns the corresponding Relation_t or MULTI_RELATION_UNKNOWN if no
    match is found.

    Note: The matching is case-sensitive: 'and' will return
    MULTI_RELATION_AND, but 'And' will return MULTI_RELATION_UNKNOWN.

    """
    return _libsbml.Relation_fromString(code)
class MultiSpeciesType(SBase):
    """

    [SBML 'multi' package]  A type of Species in SBML Level 3 'multi'

    The MultiSpeciesType class (defined simply as 'SpeciesType' in the
    SBML Level 3 'multi' specification, but called MultiSpeciesType here
    to distinguish it from the SpeciesType class defined in SBML Level 2),
    is a child of the extended Model object (via the MultiModelPlugin
    class). It defines 'id' and 'name' attributes, an optional
    'compartment' attribute for indicating which Compartment the
    referencing Species is in, and four optional lists for child
    SpeciesFeatureType, SpeciesTypeInstance, SpeciesTypeComponentIndex,
    and InSpeciesTypeBond objects.  Together those children define the
    species type.  The ListOfSpeciesTypeInstances subobject provides a way
    to define multicomponents which are instances of other
    MultiSpeciesType objects. The ListOfSpeciesFeatureTypes subobject and
    its SpeciesFeatureType children set up a framework for the referencing
    species or the instances of MultiSpeciesType objects to be able to
    have multistates. The ListOfSpeciesTypeComponentIndexes subobject
    provides a flexible way to reference any component in a
    MultiSpeciesType.  The ListOfInSpeciesTypeBonds subobject and its
    InSpeciesTypeBond children provides a way to define bonds within a
    MultiSpeciesType.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MultiSpeciesType, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, MultiSpeciesType, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(MultiSpeciesType self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> MultiSpeciesType
        __init__(MultiSpeciesType self, unsigned int level, unsigned int version) -> MultiSpeciesType
        __init__(MultiSpeciesType self, unsigned int level) -> MultiSpeciesType
        __init__(MultiSpeciesType self) -> MultiSpeciesType
        __init__(MultiSpeciesType self, MultiPkgNamespaces multins) -> MultiSpeciesType
        __init__(MultiSpeciesType self, MultiSpeciesType orig) -> MultiSpeciesType


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            MultiSpeciesType(MultiSpeciesType orig)

        Copy constructor for MultiSpeciesType.

        Parameter 'orig' is the MultiSpeciesType instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            MultiSpeciesType(long level      =
        MultiExtension.getDefaultLevel(), long version    =
        MultiExtension.getDefaultVersion(), long pkgVersion =
        MultiExtension.getDefaultPackageVersion())

        Creates a new MultiSpeciesType object.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            MultiSpeciesType(MultiPkgNamespaces multins)

        Creates a new MultiSpeciesType with the given MultiPkgNamespaces
        object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'multins' is the MultiPkgNamespaces object

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_MultiSpeciesType(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(MultiSpeciesType self) -> MultiSpeciesType


        Creates and returns a deep copy of this MultiSpeciesType object.

        Returns a (deep) copy of this MultiSpeciesType object.

        """
        return _libsbml.MultiSpeciesType_clone(self)

    __swig_destroy__ = _libsbml.delete_MultiSpeciesType
    __del__ = lambda self: None

    def getId(self):
        """
        getId(MultiSpeciesType self) -> string


        Returns the value of the 'id' attribute of this MultiSpeciesType.

        Returns the value of the 'id' attribute of this MultiSpeciesType as a
        string.

        """
        return _libsbml.MultiSpeciesType_getId(self)


    def isSetId(self):
        """
        isSetId(MultiSpeciesType self) -> bool


        Returns 'True' if whether this MultiSpeciesType's 'id' attribute has
        been set.

        Returns 'True' if this MultiSpeciesType's 'id' attribute has been set;
        otherwise, 'False' is returned.

        """
        return _libsbml.MultiSpeciesType_isSetId(self)


    def setId(self, id):
        """
        setId(MultiSpeciesType self, string id) -> int


        Sets the value of the 'id' attribute of this MultiSpeciesType.

        Parameter 'id' is string value of the 'id' attribute to be set

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.MultiSpeciesType_setId(self, id)


    def unsetId(self):
        """
        unsetId(MultiSpeciesType self) -> int


        Unsets the value of the 'id' attribute of this MultiSpeciesType.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.MultiSpeciesType_unsetId(self)


    def getName(self):
        """
        getName(MultiSpeciesType self) -> string


        Returns the value of the 'name' attribute of this MultiSpeciesType.

        Returns the value of the 'name' attribute of this MultiSpeciesType as
        a string.

        """
        return _libsbml.MultiSpeciesType_getName(self)


    def isSetName(self):
        """
        isSetName(MultiSpeciesType self) -> bool


        Returns 'True' if this MultiSpeciesType's 'name' attribute has been
        set.

        Returns 'True' if this MultiSpeciesType's 'name' attribute has been
        set; otherwise, 'False' is returned.

        """
        return _libsbml.MultiSpeciesType_isSetName(self)


    def setName(self, name):
        """
        setName(MultiSpeciesType self, string name) -> int


        Sets the value of the 'name' attribute of this MultiSpeciesType.

        Parameter 'name' is string value of the 'name' attribute to be set

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.MultiSpeciesType_setName(self, name)


    def unsetName(self):
        """
        unsetName(MultiSpeciesType self) -> int


        Unsets the value of the 'name' attribute of this MultiSpeciesType.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.MultiSpeciesType_unsetName(self)


    def getCompartment(self):
        """
        getCompartment(MultiSpeciesType self) -> string


        Returns the value of the 'compartment' attribute of this
        MultiSpeciesType.

        Returns the value of the 'compartment' attribute of this
        MultiSpeciesType as a string.

        """
        return _libsbml.MultiSpeciesType_getCompartment(self)


    def isSetCompartment(self):
        """
        isSetCompartment(MultiSpeciesType self) -> bool


        Returns 'True' if this MultiSpeciesType's 'compartment' attribute has
        been set.

        Returns 'True' if this MultiSpeciesType's 'compartment' attribute has
        been set; otherwise, 'False' is returned.

        """
        return _libsbml.MultiSpeciesType_isSetCompartment(self)


    def setCompartment(self, compartment):
        """
        setCompartment(MultiSpeciesType self, string compartment) -> int


        Sets the value of the 'compartment' attribute of this
        MultiSpeciesType.

        Parameter 'compartment' is the new value for the attribute.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.MultiSpeciesType_setCompartment(self, compartment)


    def unsetCompartment(self):
        """
        unsetCompartment(MultiSpeciesType self) -> int


        Unsets the value of the 'compartment' attribute of this
        MultiSpeciesType.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.MultiSpeciesType_unsetCompartment(self)


    def getListOfSpeciesFeatureTypes(self, *args):
        """
        getListOfSpeciesFeatureTypes(MultiSpeciesType self) -> ListOfSpeciesFeatureTypes
        getListOfSpeciesFeatureTypes(MultiSpeciesType self) -> ListOfSpeciesFeatureTypes


        Returns the ListOfSpeciesFeatureTypes in this MultiSpeciesType object.

        Returns the ListOfSpeciesFeatureTypes child of this MultiSpeciesType.

        """
        return _libsbml.MultiSpeciesType_getListOfSpeciesFeatureTypes(self, *args)


    def getSpeciesFeatureType(self, *args):
        """
        getSpeciesFeatureType(MultiSpeciesType self, unsigned int n) -> SpeciesFeatureType
        getSpeciesFeatureType(MultiSpeciesType self, unsigned int n) -> SpeciesFeatureType
        getSpeciesFeatureType(MultiSpeciesType self, string sid) -> SpeciesFeatureType
        getSpeciesFeatureType(MultiSpeciesType self, string sid) -> SpeciesFeatureType


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getSpeciesFeatureType(long n)

        Returns the nth SpeciesFeatureType object from the
        ListOfSpeciesFeatureTypes.

        Parameter 'n' is the index number of the SpeciesFeatureType to get.

        Returns the nth SpeciesFeatureType in the ListOfSpeciesFeatureTypes
        within this MultiSpeciesType. If the index 'n' is invalid, 'None' is
        returned.

        See also getNumSpeciesFeatureTypes().

        ______________________________________________________________________
        Method variant with the following signature:

            getSpeciesFeatureType(string sid)

        Get a SpeciesFeatureType from the ListOfSpeciesFeatureTypes based on
        its identifier.

        Parameter 'sid' is a string representing the identifier of the
        SpeciesFeatureType to get.

        Returns the SpeciesFeatureType in the ListOfSpeciesFeatureTypes with
        the given id, or 'None' if no such SpeciesFeatureType exists.

        See also getSpeciesFeatureType(), getNumSpeciesFeatureTypes().

        """
        return _libsbml.MultiSpeciesType_getSpeciesFeatureType(self, *args)


    def addSpeciesFeatureType(self, sft):
        """
        addSpeciesFeatureType(MultiSpeciesType self, SpeciesFeatureType sft) -> int


        Adds a copy the given 'SpeciesFeatureType' to this MultiSpeciesType.

        Parameter 'sft' is the SpeciesFeatureType object to add

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.MultiSpeciesType_addSpeciesFeatureType(self, sft)


    def getNumSpeciesFeatureTypes(self):
        """
        getNumSpeciesFeatureTypes(MultiSpeciesType self) -> unsigned int


        Get the number of SpeciesFeatureType objects in this MultiSpeciesType.

        Returns the number of SpeciesFeatureType objects in this
        MultiSpeciesType

        """
        return _libsbml.MultiSpeciesType_getNumSpeciesFeatureTypes(self)


    def createSpeciesFeatureType(self):
        """
        createSpeciesFeatureType(MultiSpeciesType self) -> SpeciesFeatureType


        Creates a new SpeciesFeatureType object and adds it to this
        MultiSpeciesTypes ListOfSpeciesFeatureTypes.

        Returns the newly created SpeciesFeatureType object instance.

        See also addSpeciesFeatureType().

        """
        return _libsbml.MultiSpeciesType_createSpeciesFeatureType(self)


    def removeSpeciesFeatureType(self, *args):
        """
        removeSpeciesFeatureType(MultiSpeciesType self, unsigned int n) -> SpeciesFeatureType
        removeSpeciesFeatureType(MultiSpeciesType self, string sid) -> SpeciesFeatureType


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeSpeciesFeatureType(long n)

        Removes the nth SpeciesFeatureType from the ListOfSpeciesFeatureTypes
        within this MultiSpeciesType object.

        Parameter 'n' is the index of the SpeciesFeatureType to remove.

        Returns the SpeciesFeatureType object removed, or 'None' if the given
        index 'n' is out of range.  Note that the caller owns the returned
        object and is responsible for deleting it.

        See also getNumSpeciesFeatureTypes().

        ______________________________________________________________________
        Method variant with the following signature:

            removeSpeciesFeatureType(string sid)

        Removes the SpeciesFeatureType with the given identifier from the
        ListOfSpeciesFeatureTypes object.

        Parameter 'sid' is the identifier of the SpeciesFeatureType to remove.

        Returns the SpeciesFeatureType removed, or 'None' if none have the
        identifier 'sid'.  Note that the caller owns the returned item and is
        responsible for deleting it.

        """
        return _libsbml.MultiSpeciesType_removeSpeciesFeatureType(self, *args)


    def getListOfSpeciesTypeInstances(self, *args):
        """
        getListOfSpeciesTypeInstances(MultiSpeciesType self) -> ListOfSpeciesTypeInstances
        getListOfSpeciesTypeInstances(MultiSpeciesType self) -> ListOfSpeciesTypeInstances


        Returns the ListOfSpeciesTypeInstances in this MultiSpeciesType
        object.

        Returns the ListOfSpeciesTypeInstances child of this MultiSpeciesType.

        """
        return _libsbml.MultiSpeciesType_getListOfSpeciesTypeInstances(self, *args)


    def getSpeciesTypeInstance(self, *args):
        """
        getSpeciesTypeInstance(MultiSpeciesType self, unsigned int n) -> SpeciesTypeInstance
        getSpeciesTypeInstance(MultiSpeciesType self, unsigned int n) -> SpeciesTypeInstance
        getSpeciesTypeInstance(MultiSpeciesType self, string sid) -> SpeciesTypeInstance
        getSpeciesTypeInstance(MultiSpeciesType self, string sid) -> SpeciesTypeInstance


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getSpeciesTypeInstance(long n)

        Get the nth SpeciesTypeInstance object from the
        ListOfSpeciesTypeInstances.

        Parameter 'n' is the index number of the SpeciesTypeInstance to get.

        Returns the nth SpeciesTypeInstance object in the
        ListOfSpeciesTypeInstances, or 'None' if the given index is out of
        range.

        See also getNumSpeciesTypeInstances().

        ______________________________________________________________________
        Method variant with the following signature:

            getSpeciesTypeInstance(string sid)

        Get a SpeciesTypeInstance from the ListOfSpeciesTypeInstances based on
        its identifier.

        Parameter 'sid' is a string representing the identifier of the
        SpeciesTypeInstance to get.

        Returns the SpeciesTypeInstance in the ListOfSpeciesTypeInstances with
        the given id, or 'None' if no such SpeciesTypeInstance exists.

        See also getSpeciesTypeInstance(), getNumSpeciesTypeInstances().

        """
        return _libsbml.MultiSpeciesType_getSpeciesTypeInstance(self, *args)


    def addSpeciesTypeInstance(self, sti):
        """
        addSpeciesTypeInstance(MultiSpeciesType self, SpeciesTypeInstance sti) -> int


        Adds a copy the given 'SpeciesTypeInstance' to this MultiSpeciesType.

        Parameter 'sti' is the SpeciesTypeInstance object to add

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.MultiSpeciesType_addSpeciesTypeInstance(self, sti)


    def getNumSpeciesTypeInstances(self):
        """
        getNumSpeciesTypeInstances(MultiSpeciesType self) -> unsigned int


        Get the number of SpeciesTypeInstance objects in this
        MultiSpeciesType.

        Returns the number of SpeciesTypeInstance objects in this
        MultiSpeciesType

        """
        return _libsbml.MultiSpeciesType_getNumSpeciesTypeInstances(self)


    def createSpeciesTypeInstance(self):
        """
        createSpeciesTypeInstance(MultiSpeciesType self) -> SpeciesTypeInstance


        Creates a new SpeciesTypeInstance object and adds it to this
        MultiSpeciesTypes ListOfSpeciesTypeInstances.

        Returns a new SpeciesTypeInstance object instance.

        See also addSpeciesTypeInstance().

        """
        return _libsbml.MultiSpeciesType_createSpeciesTypeInstance(self)


    def removeSpeciesTypeInstance(self, *args):
        """
        removeSpeciesTypeInstance(MultiSpeciesType self, unsigned int n) -> SpeciesTypeInstance
        removeSpeciesTypeInstance(MultiSpeciesType self, string sid) -> SpeciesTypeInstance


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeSpeciesTypeInstance(long n)

        Removes the nth SpeciesTypeInstance from the
        ListOfSpeciesTypeInstances within this MultiSpeciesType.

        Parameter 'n' is the index of the SpeciesTypeInstance to remove.

        Returns the object removed, or 'None' if no such object exists.  Note
        that the caller owns the returned object and is responsible for
        deleting it.

        See also getNumSpeciesTypeInstances().

        ______________________________________________________________________
        Method variant with the following signature:

            removeSpeciesTypeInstance(string sid)

        Removes the SpeciesTypeInstance with the given identifier from the
        ListOfSpeciesTypeInstances within this MultiSpeciesType.

        Parameter 'sid' is the identifier of the SpeciesTypeInstance to
        remove.

        Returns the object removed, or 'None' if no such object exists.  Note
        that the caller owns the returned object and is responsible for
        deleting it.

        """
        return _libsbml.MultiSpeciesType_removeSpeciesTypeInstance(self, *args)


    def getListOfSpeciesTypeComponentIndexes(self, *args):
        """
        getListOfSpeciesTypeComponentIndexes(MultiSpeciesType self) -> ListOfSpeciesTypeComponentIndexes
        getListOfSpeciesTypeComponentIndexes(MultiSpeciesType self) -> ListOfSpeciesTypeComponentIndexes


        Returns the ListOfSpeciesTypeComponentIndexes object.

        Returns the ListOfSpeciesTypeComponentIndexes object in this
        MultiSpeciesType object.

        """
        return _libsbml.MultiSpeciesType_getListOfSpeciesTypeComponentIndexes(self, *args)


    def getSpeciesTypeComponentIndex(self, *args):
        """
        getSpeciesTypeComponentIndex(MultiSpeciesType self, unsigned int n) -> SpeciesTypeComponentIndex
        getSpeciesTypeComponentIndex(MultiSpeciesType self, unsigned int n) -> SpeciesTypeComponentIndex
        getSpeciesTypeComponentIndex(MultiSpeciesType self, string sid) -> SpeciesTypeComponentIndex
        getSpeciesTypeComponentIndex(MultiSpeciesType self, string sid) -> SpeciesTypeComponentIndex


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getSpeciesTypeComponentIndex(long n)

        Get the nth SpeciesTypeComponentIndex object from the
        ListOfSpeciesTypeComponentIndexes.

        Parameter 'n' is the index number of the SpeciesTypeComponentIndex to
        get from the ListOfSpeciesTypeComponentIndexes.

        Returns the nth object in the ListOfSpeciesTypeComponentIndexes, or
        'None' if the index 'n' is out of range.

        See also getNumSpeciesTypeComponentIndexes().

        ______________________________________________________________________
        Method variant with the following signature:

            getSpeciesTypeComponentIndex(string sid)

        Get a SpeciesTypeComponentIndex object based on its identifier.

        Parameter 'sid' is a string representing the identifier of the
        SpeciesTypeComponentIndex to get from the
        ListOfSpeciesTypeComponentIndexes.

        Returns the object with the given id, or 'None' if no such object
        exists.

        See also getSpeciesTypeComponentIndex(),
        getNumSpeciesTypeComponentIndexes().

        """
        return _libsbml.MultiSpeciesType_getSpeciesTypeComponentIndex(self, *args)


    def addSpeciesTypeComponentIndex(self, stci):
        """
        addSpeciesTypeComponentIndex(MultiSpeciesType self, SpeciesTypeComponentIndex stci) -> int


        Adds a copy of the given SpeciesTypeComponentIndex object to this
        MultiSpeciesType.

        Parameter 'stci' is the SpeciesTypeComponentIndex object to add

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.MultiSpeciesType_addSpeciesTypeComponentIndex(self, stci)


    def getNumSpeciesTypeComponentIndexes(self):
        """
        getNumSpeciesTypeComponentIndexes(MultiSpeciesType self) -> unsigned int


        Get the number of SpeciesTypeComponentIndex objects in this
        MultiSpeciesType.

        Returns the number of SpeciesTypeComponentIndex objects in the
        ListOfSpeciesTypeComponentIndexes object within this MultiSpeciesType
        object.

        """
        return _libsbml.MultiSpeciesType_getNumSpeciesTypeComponentIndexes(self)


    def createSpeciesTypeComponentIndex(self):
        """
        createSpeciesTypeComponentIndex(MultiSpeciesType self) -> SpeciesTypeComponentIndex


        Creates a new SpeciesTypeComponentIndex object and adds it to the
        ListOfSpeciesTypeComponentIndexes.

        Returns a new SpeciesTypeComponentIndex object instance to add to the
        ListOfSpeciesTypeComponentIndexes object within this MultiSpeciesType
        object.

        See also addSpeciesTypeComponentIndex().

        """
        return _libsbml.MultiSpeciesType_createSpeciesTypeComponentIndex(self)


    def removeSpeciesTypeComponentIndex(self, *args):
        """
        removeSpeciesTypeComponentIndex(MultiSpeciesType self, unsigned int n) -> SpeciesTypeComponentIndex
        removeSpeciesTypeComponentIndex(MultiSpeciesType self, string sid) -> SpeciesTypeComponentIndex


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeSpeciesTypeComponentIndex(long n)

        Removes the nth SpeciesTypeComponentIndex object from the
        ListOfSpeciesTypeComponentIndexes.

        Parameter 'n' is the index of the SpeciesTypeComponentIndex to remove.

        Returns the object removed, or 'None' if no such object exists.  Note
        that the caller owns the returned object and is responsible for
        deleting it.

        See also getNumSpeciesTypeComponentIndexes().

        ______________________________________________________________________
        Method variant with the following signature:

            removeSpeciesTypeComponentIndex(string sid)

        Removes the SpeciesTypeComponentIndex object with the given identifier
        'sid'.

        Parameter 'sid' is the identifier to search for.

        Returns the object removed, or 'None' if no such object exists.  Note
        that the caller owns the returned object and is responsible for
        deleting it.

        See also getNumSpeciesTypeComponentIndexes().

        """
        return _libsbml.MultiSpeciesType_removeSpeciesTypeComponentIndex(self, *args)


    def getListOfInSpeciesTypeBonds(self, *args):
        """
        getListOfInSpeciesTypeBonds(MultiSpeciesType self) -> ListOfInSpeciesTypeBonds
        getListOfInSpeciesTypeBonds(MultiSpeciesType self) -> ListOfInSpeciesTypeBonds


        Returns the ListOfInSpeciesTypeBonds object.

        Returns the ListOfInSpeciesTypeBonds child of this MultiSpeciesType.

        """
        return _libsbml.MultiSpeciesType_getListOfInSpeciesTypeBonds(self, *args)


    def getInSpeciesTypeBond(self, *args):
        """
        getInSpeciesTypeBond(MultiSpeciesType self, unsigned int n) -> InSpeciesTypeBond
        getInSpeciesTypeBond(MultiSpeciesType self, unsigned int n) -> InSpeciesTypeBond
        getInSpeciesTypeBond(MultiSpeciesType self, string sid) -> InSpeciesTypeBond
        getInSpeciesTypeBond(MultiSpeciesType self, string sid) -> InSpeciesTypeBond


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getInSpeciesTypeBond(long n)

        Get the nth InSpeciesTypeBond object from the
        ListOfInSpeciesTypeBonds.

        Parameter 'n' is the index number of the InSpeciesTypeBond to get.

        Returns the nth object, or 'None' if the index 'is' out of range.

        See also getNumInSpeciesTypeBonds().

        ______________________________________________________________________
        Method variant with the following signature:

            getInSpeciesTypeBond(string sid)

        Get the InSpeciesTypeBond object with the given identifier 'sid'.

        Parameter 'sid' is a string representing the identifier of the
        InSpeciesTypeBond to get from this ListOfInSpeciesTypeBonds.

        Returns the object removed, or 'None' if no such object exists.  Note
        that the caller owns the returned object and is responsible for
        deleting it.

        See also getInSpeciesTypeBond(), getNumInSpeciesTypeBonds().

        """
        return _libsbml.MultiSpeciesType_getInSpeciesTypeBond(self, *args)


    def addInSpeciesTypeBond(self, istb):
        """
        addInSpeciesTypeBond(MultiSpeciesType self, InSpeciesTypeBond istb) -> int


        Adds a copy the given InSpeciesTypeBond object to this
        MultiSpeciesType.

        Parameter 'istb' is the InSpeciesTypeBond object to add

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.MultiSpeciesType_addInSpeciesTypeBond(self, istb)


    def getNumInSpeciesTypeBonds(self):
        """
        getNumInSpeciesTypeBonds(MultiSpeciesType self) -> unsigned int


        Get the number of InSpeciesTypeBond objects in the
        ListOfInSpeciesTypeBonds.

        Returns the number of InSpeciesTypeBond objects in the
        ListOfInSpeciesTypeBonds within this MultiSpeciesType object.

        """
        return _libsbml.MultiSpeciesType_getNumInSpeciesTypeBonds(self)


    def createInSpeciesTypeBond(self):
        """
        createInSpeciesTypeBond(MultiSpeciesType self) -> InSpeciesTypeBond


        Creates a new InSpeciesTypeBond object and adds it to the
        ListOfInSpeciesTypeBonds.

        Returns a new InSpeciesTypeBond object instance.

        See also addInSpeciesTypeBond().

        """
        return _libsbml.MultiSpeciesType_createInSpeciesTypeBond(self)


    def removeInSpeciesTypeBond(self, *args):
        """
        removeInSpeciesTypeBond(MultiSpeciesType self, unsigned int n) -> InSpeciesTypeBond
        removeInSpeciesTypeBond(MultiSpeciesType self, string sid) -> InSpeciesTypeBond


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeInSpeciesTypeBond(long n)

        Removes the nth InSpeciesTypeBond object from the
        ListOfInSpeciesTypeBonds.  and returns a pointer to it.

        Parameter 'n' is the index of the InSpeciesTypeBond to remove.

        Returns the nth object, or 'None' if the index 'is' out of range.

        See also getNumInSpeciesTypeBonds().

        ______________________________________________________________________
        Method variant with the following signature:

            removeInSpeciesTypeBond(string sid)

        Removes the InSpeciesTypeBond with the given identifier 'sid'.

        Parameter 'sid' is the identifier of the InSpeciesTypeBond to remove
        from the ListOfInSpeciesTypeBonds within this MultiSpeciesType object.

        Returns the object removed, or 'None' if no such object exists.  Note
        that the caller owns the returned object and is responsible for
        deleting it.

        """
        return _libsbml.MultiSpeciesType_removeInSpeciesTypeBond(self, *args)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(MultiSpeciesType self, string oldid, string newid)


        Renames all the 'SIdRef' attributes on this element, including any
        found in MathML content (if such exists).

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas, comparing the identifiers to the value of
        'oldid'.  If any matches are found, the matching identifiers are
        replaced with 'newid'.  The method does not descend into child
        elements.

        Parameter 'oldid' is the old identifier Parameter 'newid' is the new
        identifier

        """
        return _libsbml.MultiSpeciesType_renameSIdRefs(self, oldid, newid)


    def getElementName(self):
        """
        getElementName(MultiSpeciesType self) -> string


        Returns the XML element name of this object, which for
        MultiSpeciesType, is always ''multiSpeciesType'.'

        Returns the name of this element, i.e. ''multiSpeciesType'.'

        """
        return _libsbml.MultiSpeciesType_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(MultiSpeciesType self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object:
        SBML_MULTI_BINDING_SITE_SPECIES_TYPE.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.MultiSpeciesType_getTypeCode(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(MultiSpeciesType self) -> bool


        Returns 'True' if this object has all the required attributes.

        Note: The required attributes for a MultiSpeciesType object are:

        * 'id'

        Returns 'True' if this object has all the elements required by the
        package specification; otherwise, 'False' will be returned.

        """
        return _libsbml.MultiSpeciesType_hasRequiredAttributes(self)


    def hasRequiredElements(self):
        """
        hasRequiredElements(MultiSpeciesType self) -> bool


        Returns 'True' if this object has all the required elements.

        Returns 'True' if this object has all the elements required by the
        package specification; otherwise, 'False' will be returned.

        """
        return _libsbml.MultiSpeciesType_hasRequiredElements(self)


    def connectToChild(self):
        """
        connectToChild(MultiSpeciesType self)


        Internal implementation method.

        """
        return _libsbml.MultiSpeciesType_connectToChild(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(MultiSpeciesType self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.MultiSpeciesType_enablePackageInternal(self, pkgURI, pkgPrefix, flag)

MultiSpeciesType_swigregister = _libsbml.MultiSpeciesType_swigregister
MultiSpeciesType_swigregister(MultiSpeciesType)

class ListOfMultiSpeciesTypes(ListOf):
    """

    [SBML 'multi' package]  A list of MultiSpeciesType objects.

    The ListOfMultiSpeciesTypes is a container for MultiSpeciesType
    objects.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    See also MultiSpeciesType.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfMultiSpeciesTypes, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfMultiSpeciesTypes, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ListOfMultiSpeciesTypes self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ListOfMultiSpeciesTypes
        __init__(ListOfMultiSpeciesTypes self, unsigned int level, unsigned int version) -> ListOfMultiSpeciesTypes
        __init__(ListOfMultiSpeciesTypes self, unsigned int level) -> ListOfMultiSpeciesTypes
        __init__(ListOfMultiSpeciesTypes self) -> ListOfMultiSpeciesTypes
        __init__(ListOfMultiSpeciesTypes self, MultiPkgNamespaces multins) -> ListOfMultiSpeciesTypes


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfMultiSpeciesTypes(long level      =
        MultiExtension.getDefaultLevel(), long version    =
        MultiExtension.getDefaultVersion(), long pkgVersion =
        MultiExtension.getDefaultPackageVersion())

        Creates a new ListOfMultiSpeciesTypes object

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfMultiSpeciesTypes(MultiPkgNamespaces multins)

        Creates a new ListOfMultiSpeciesTypes with the given
        MultiPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'multins' is the MultiPkgNamespaces object

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_ListOfMultiSpeciesTypes(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ListOfMultiSpeciesTypes self) -> ListOfMultiSpeciesTypes


        Creates and returns a deep copy of this ListOfMultiSpeciesTypes
        object.

        Returns a (deep) copy of this ListOfMultiSpeciesTypes object.

        """
        return _libsbml.ListOfMultiSpeciesTypes_clone(self)


    def get(self, *args):
        """
        get(ListOfMultiSpeciesTypes self, unsigned int n) -> MultiSpeciesType
        get(ListOfMultiSpeciesTypes self, unsigned int n) -> MultiSpeciesType
        get(ListOfMultiSpeciesTypes self, string sid) -> MultiSpeciesType
        get(ListOfMultiSpeciesTypes self, string sid) -> MultiSpeciesType


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get the nth MultiSpeciesType from the ListOfMultiSpeciesTypes.

        Parameter 'n' is the index number of the MultiSpeciesType to get.

        Returns the nth object, or 'None' if the index 'is' out of range.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get the MultiSpeciesType with the given identifier 'sid'.

        Parameter 'sid' is a string representing the identifier of the
        MultiSpeciesType to get from this ListOfMultiSpeciesTypes.

        Returns the object with the given id, or 'None' if no such object
        exists.

        See also get()   *, size().

        """
        return _libsbml.ListOfMultiSpeciesTypes_get(self, *args)


    def remove(self, *args):
        """
        remove(ListOfMultiSpeciesTypes self, unsigned int n) -> MultiSpeciesType
        remove(ListOfMultiSpeciesTypes self, string sid) -> MultiSpeciesType


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth MultiSpeciesType from this ListOfMultiSpeciesTypes.

        Parameter 'n' is the index of the MultiSpeciesType to remove.

        Returns the object removed, or 'None' if no such object exists.  Note
        that the caller owns the returned object and is responsible for
        deleting it.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes the MultiSpeciesType with the given identifier 'sid'.

        Parameter 'sid' is the identifier of the MultiSpeciesType to remove.

        Returns the object removed, or 'None' if no such object exists.  Note
        that the caller owns the returned object and is responsible for
        deleting it.

        """
        return _libsbml.ListOfMultiSpeciesTypes_remove(self, *args)


    def getElementName(self):
        """
        getElementName(ListOfMultiSpeciesTypes self) -> string


        Returns the XML element name of this object.

        Returns the name of this element, i.e. ''listOfMultiSpeciesTypes'.'

        """
        return _libsbml.ListOfMultiSpeciesTypes_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(ListOfMultiSpeciesTypes self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object:
        SBML_MULTI_BINDING_SITE_SPECIES_TYPE.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfMultiSpeciesTypes_getTypeCode(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfMultiSpeciesTypes self) -> int


        Returns the libSBML type code for the objects contained in this ListOf
        (i.e., Compartment objects, if the list is non-empty).

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for the objects contained in this ListOf
        instance: SBML_COMPARTMENT (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfMultiSpeciesTypes_getItemTypeCode(self)

    __swig_destroy__ = _libsbml.delete_ListOfMultiSpeciesTypes
    __del__ = lambda self: None
ListOfMultiSpeciesTypes_swigregister = _libsbml.ListOfMultiSpeciesTypes_swigregister
ListOfMultiSpeciesTypes_swigregister(ListOfMultiSpeciesTypes)

class BindingSiteSpeciesType(MultiSpeciesType):
    """

    [SBML 'multi' package]  Extension of MultiSpeciesType to define a
    binding site.

    A BindingSiteSpeciesType inherits from MultiSpeciesType, and also is a
    child of the extended Model (via the MultiModelPlugin). A
    BindingSiteSpeciesType object defines a binding site, and therefore
    its instance can further define the bindingStatus attribute and can
    participate a binding internally and explicitly in an
    InSpeciesTypeBond object, or externally and implicitly defined by an
    OutwardBindingSite object. A binding site must be an atomic component
    which means that a BindingSiteSpeciesType object cannot contain a
    ListOfSpeciesTypeInstances subobject. Note: In the Multi package, a
    binding site can only participate in one binding at a time. That means
    a binding site cannot bind two partners at the same time. The binding
    relationship is one-to-one.

    """

    __swig_setmethods__ = {}
    for _s in [MultiSpeciesType]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BindingSiteSpeciesType, name, value)
    __swig_getmethods__ = {}
    for _s in [MultiSpeciesType]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, BindingSiteSpeciesType, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(BindingSiteSpeciesType self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> BindingSiteSpeciesType
        __init__(BindingSiteSpeciesType self, unsigned int level, unsigned int version) -> BindingSiteSpeciesType
        __init__(BindingSiteSpeciesType self, unsigned int level) -> BindingSiteSpeciesType
        __init__(BindingSiteSpeciesType self) -> BindingSiteSpeciesType
        __init__(BindingSiteSpeciesType self, MultiPkgNamespaces multins) -> BindingSiteSpeciesType
        __init__(BindingSiteSpeciesType self, BindingSiteSpeciesType orig) -> BindingSiteSpeciesType


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            BindingSiteSpeciesType(BindingSiteSpeciesType orig)

        Copy constructor for BindingSiteSpeciesType.

        Parameter 'orig' is the BindingSiteSpeciesType instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            BindingSiteSpeciesType(long level      =
        MultiExtension.getDefaultLevel(), long version    =
        MultiExtension.getDefaultVersion(), long pkgVersion =
        MultiExtension.getDefaultPackageVersion())

        Creates a new BindingSiteSpeciesType object.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            BindingSiteSpeciesType(MultiPkgNamespaces multins)

        Creates a new BindingSiteSpeciesType with the given MultiPkgNamespaces
        object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'multins' is the MultiPkgNamespaces object

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_BindingSiteSpeciesType(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(BindingSiteSpeciesType self) -> BindingSiteSpeciesType


        Creates and returns a deep copy of this BindingSiteSpeciesType object.

        Returns a (deep) copy of this BindingSiteSpeciesType object.

        """
        return _libsbml.BindingSiteSpeciesType_clone(self)

    __swig_destroy__ = _libsbml.delete_BindingSiteSpeciesType
    __del__ = lambda self: None

    def getElementName(self):
        """
        getElementName(BindingSiteSpeciesType self) -> string


        Returns the XML element name of this object.

        Returns the name of this element, i.e. ''bindingSiteSpeciesType'.'

        """
        return _libsbml.BindingSiteSpeciesType_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(BindingSiteSpeciesType self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object:
        SBML_MULTI_BINDING_SITE_SPECIES_TYPE.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.BindingSiteSpeciesType_getTypeCode(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(BindingSiteSpeciesType self) -> bool


        Returns 'True' if this object has all the required elements.

        Returns 'True' if this object has all the elements required by the
        package specification; otherwise, 'False' will be returned.

        """
        return _libsbml.BindingSiteSpeciesType_hasRequiredAttributes(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(BindingSiteSpeciesType self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.BindingSiteSpeciesType_enablePackageInternal(self, pkgURI, pkgPrefix, flag)

BindingSiteSpeciesType_swigregister = _libsbml.BindingSiteSpeciesType_swigregister
BindingSiteSpeciesType_swigregister(BindingSiteSpeciesType)

class IntraSpeciesReaction(Reaction):
    """

    [SBML 'multi' package]  A subclass of Reaction for changes of an
    internal species bond.

    An IntraSpeciesReaction is derived from Reaction for the reactions
    happening within a Species. A particular Reaction may happen within a
    Species as an IntraSpeciesReaction if the following conditions are
    fulfilled:

    * The Reaction is either an association reaction or a dissociation
    reaction.

    * If it is an association reaction, each of the two reactant
    Species has at least one OutwardBindingSite free ('unbound').

    * If it is a dissociation reaction, each of the two product
    Species has at least one OutwardBindingSite free ('unbound').

    Note: Technically, transformations are also reactions happening with
    one Species, but they do not have the ambiguity of association and
    dissociation reactions. Therefore, a transformation reaction does not
    have to be defined as an IntraSpeciesReaction.

    """

    __swig_setmethods__ = {}
    for _s in [Reaction]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, IntraSpeciesReaction, name, value)
    __swig_getmethods__ = {}
    for _s in [Reaction]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, IntraSpeciesReaction, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(IntraSpeciesReaction self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> IntraSpeciesReaction
        __init__(IntraSpeciesReaction self, unsigned int level, unsigned int version) -> IntraSpeciesReaction
        __init__(IntraSpeciesReaction self, unsigned int level) -> IntraSpeciesReaction
        __init__(IntraSpeciesReaction self) -> IntraSpeciesReaction
        __init__(IntraSpeciesReaction self, MultiPkgNamespaces multins) -> IntraSpeciesReaction
        __init__(IntraSpeciesReaction self, IntraSpeciesReaction orig) -> IntraSpeciesReaction


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            IntraSpeciesReaction(IntraSpeciesReaction orig)

        Copy constructor for IntraSpeciesReaction.

        Parameter 'orig' is the IntraSpeciesReaction instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            IntraSpeciesReaction(long level      =
        MultiExtension.getDefaultLevel(), long version    =
        MultiExtension.getDefaultVersion(), long pkgVersion =
        MultiExtension.getDefaultPackageVersion())

        Creates a new IntraSpeciesReaction with the given level, version, and
        package version.

        Parameter 'level' is the SBML Level. Parameter 'version' is the
        Version within the SBML Level. Parameter 'pkgVersion' is the version
        of the package.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            IntraSpeciesReaction(MultiPkgNamespaces multins)

        Creates a new IntraSpeciesReaction with the given MultiPkgNamespaces
        object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'multins' is the MultiPkgNamespaces object

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_IntraSpeciesReaction(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(IntraSpeciesReaction self) -> IntraSpeciesReaction


        Creates and returns a deep copy of this IntraSpeciesReaction object.

        Returns a (deep) copy of this IntraSpeciesReaction object.

        """
        return _libsbml.IntraSpeciesReaction_clone(self)

    __swig_destroy__ = _libsbml.delete_IntraSpeciesReaction
    __del__ = lambda self: None

    def getElementName(self):
        """
        getElementName(IntraSpeciesReaction self) -> string


        Returns the XML element name of this object.

        Returns the name of this element, i.e. ''intraSpeciesReaction'.'

        """
        return _libsbml.IntraSpeciesReaction_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(IntraSpeciesReaction self) -> int


        Returns the libSBML type code for this SBML object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object:
        SBML_MULTI_BINDING_SITE_SPECIES_TYPE.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.IntraSpeciesReaction_getTypeCode(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(IntraSpeciesReaction self) -> bool


        Returns 'True' if this object has all the required elements.

        Returns 'True' if this object has all the elements required by the
        package specification; otherwise, 'False' will be returned.

        """
        return _libsbml.IntraSpeciesReaction_hasRequiredAttributes(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(IntraSpeciesReaction self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.IntraSpeciesReaction_enablePackageInternal(self, pkgURI, pkgPrefix, flag)

IntraSpeciesReaction_swigregister = _libsbml.IntraSpeciesReaction_swigregister
IntraSpeciesReaction_swigregister(IntraSpeciesReaction)

class MultiASTPlugin(ASTBasePlugin):
    """

    [SBML 'multi' package]  Extension of ASTBasePlugin.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    The MultiASTPlugin object is used to extend the standard SBML AST
    (abstract syntax tree) base object (ASTBase) to allow a 'ci' element
    (AST_NAME) to have an optional 'speciesReference' attribute.  This
    attribute is used to distinguish which version of a Species should be
    used in the mathematics.  If a 'template' type Species appears as both
    a reactant and a product in the same Reaction, for example, it may
    have one amount as a reactant and a different amount as a product,
    since the same template is being used to match slightly different
    pools of elements in each case.  By defining the 'speciesReference'
    attribute on an AST_NAME that references that Species, the modeler may
    determine which amount is being referenced.  Similarly, an AST_NAME
    node may reference a SpeciesFeature that appears in multiple Species
    in the Reaction, and this attribute can be used to specify which one
    should be used.

    """

    __swig_setmethods__ = {}
    for _s in [ASTBasePlugin]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MultiASTPlugin, name, value)
    __swig_getmethods__ = {}
    for _s in [ASTBasePlugin]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, MultiASTPlugin, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(MultiASTPlugin self, string uri) -> MultiASTPlugin
        __init__(MultiASTPlugin self, MultiASTPlugin orig) -> MultiASTPlugin


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            MultiASTPlugin(string &uri)

        Creates a new MultiASTPlugin object using the given parameters.

        In the XML representation of an SBML document, XML namespaces are
        used to identify the origin of each XML construct used.  XML
        namespaces are identified by their unique resource identifiers (URIs).
        The core SBML specifications stipulate the namespaces that must be
        used for core SBML constructs; for example, all XML elements that
        belong to SBML Level 3 Version 1 Core must be placed in the XML
        namespace identified by the URI
        'http://www.sbml.org/sbml/level3/version1/core'.  Individual SBML
        Level 3 packages define their own XML namespaces; for example, all
        elements belonging to the SBML Level 3 Layout Version 1 package must
        be placed in the XML namespace
        'http://www.sbml.org/sbml/level3/version1/layout/version1/'.

        Parameter 'uri' is the URI of the SBML Level 3 package implemented by
        this libSBML package extension.

        ______________________________________________________________________
        Method variant with the following signature:

            MultiASTPlugin(MultiASTPlugin orig)

        Copy constructor.

        Parameter 'orig' is the MultiASTPlugin instance to copy.

        """
        this = _libsbml.new_MultiASTPlugin(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_MultiASTPlugin
    __del__ = lambda self: None

    def clone(self):
        """
        clone(MultiASTPlugin self) -> MultiASTPlugin


        Creates and returns a deep copy of this MultiASTPlugin object.

        Returns a (deep) copy of this SBase object

        """
        return _libsbml.MultiASTPlugin_clone(self)


    def createObject(self, stream):
        """
        createObject(MultiASTPlugin self, XMLInputStream stream) -> MultiASTPlugin


        Internal implementation method.

        """
        return _libsbml.MultiASTPlugin_createObject(self, stream)


    def getPrefix(self):
        """
        getPrefix(MultiASTPlugin self) -> string


        Internal implementation method.

        """
        return _libsbml.MultiASTPlugin_getPrefix(self)


    def connectToParent(self, astbase):
        """
        connectToParent(MultiASTPlugin self, ASTNode astbase)


        Internal implementation method.

        """
        return _libsbml.MultiASTPlugin_connectToParent(self, astbase)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(MultiASTPlugin self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.MultiASTPlugin_enablePackageInternal(self, pkgURI, pkgPrefix, flag)


    def getSpeciesReference(self):
        """
        getSpeciesReference(MultiASTPlugin self) -> string


        Returns the value of the 'speciesReference' attribute of this
        MultiASTPlugin.

        Returns the value of the 'speciesReference' attribute of this
        MultiASTPlugin as a string.

        """
        return _libsbml.MultiASTPlugin_getSpeciesReference(self)


    def isSetSpeciesReference(self):
        """
        isSetSpeciesReference(MultiASTPlugin self) -> bool


        Predicate returning 'True' if this MultiASTPlugin's 'speciesReference'
        attribute is set.

        Returns 'True' if this MultiASTPlugin's 'speciesReference' attribute
        has been set, otherwise 'False' is returned.

        """
        return _libsbml.MultiASTPlugin_isSetSpeciesReference(self)


    def setSpeciesReference(self, speciesReference):
        """
        setSpeciesReference(MultiASTPlugin self, string speciesReference) -> int


        Sets the value of the 'speciesReference' attribute of this
        MultiASTPlugin.

        Parameter 'id' is string& value of the 'speciesReference' attribute to
        be set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        Calling this function with 'speciesReference' = 'None' or an empty
        string is equivalent to calling unsetSpeciesReference().

        """
        return _libsbml.MultiASTPlugin_setSpeciesReference(self, speciesReference)


    def unsetSpeciesReference(self):
        """
        unsetSpeciesReference(MultiASTPlugin self) -> int


        Unsets the value of the 'speciesReference' attribute of this
        MultiASTPlugin.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.MultiASTPlugin_unsetSpeciesReference(self)


    def getRepresentationType(self):
        """
        getRepresentationType(MultiASTPlugin self) -> string


        Returns the value of the 'representationType' attribute of this
        MultiASTPlugin.

        Returns the value of the 'representationType' attribute of this
        MultiASTPlugin as a string.

        """
        return _libsbml.MultiASTPlugin_getRepresentationType(self)


    def isSetRepresentationType(self):
        """
        isSetRepresentationType(MultiASTPlugin self) -> bool


        Predicate returning 'True' if this MultiASTPlugin's
        'representationType' attribute is set.

        Returns 'True' if this MultiASTPlugin's 'representationType' attribute
        has been set, otherwise 'False' is returned.

        """
        return _libsbml.MultiASTPlugin_isSetRepresentationType(self)


    def setRepresentationType(self, representationType):
        """
        setRepresentationType(MultiASTPlugin self, string representationType) -> int


        Sets the value of the 'representationType' attribute of this
        MultiASTPlugin.

        Parameter 'id' is string& value of the 'representationType' attribute
        to be set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        Calling this function with 'representationType' = 'None' or an empty
        string is equivalent to calling unsetRepresentationType().

        """
        return _libsbml.MultiASTPlugin_setRepresentationType(self, representationType)


    def unsetRepresentationType(self):
        """
        unsetRepresentationType(MultiASTPlugin self) -> int


        Unsets the value of the 'representationType' attribute of this
        MultiASTPlugin.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.MultiASTPlugin_unsetRepresentationType(self)


    def read(self, stream, reqd_prefix, currentElement):
        """
        read(MultiASTPlugin self, XMLInputStream stream, string reqd_prefix, XMLToken currentElement) -> bool


        Internal implementation method.

        """
        return _libsbml.MultiASTPlugin_read(self, stream, reqd_prefix, currentElement)


    def addExpectedAttributes(self, attributes, stream, type):
        """
        addExpectedAttributes(MultiASTPlugin self, ExpectedAttributes & attributes, XMLInputStream stream, int type)


        Internal implementation method.

        """
        return _libsbml.MultiASTPlugin_addExpectedAttributes(self, attributes, stream, type)


    def readAttributes(self, attributes, expectedAttributes, stream, element, type):
        """
        readAttributes(MultiASTPlugin self, XMLAttributes attributes, ExpectedAttributes const & expectedAttributes, XMLInputStream stream, XMLToken element, int type) -> bool


        Internal implementation method.

        """
        return _libsbml.MultiASTPlugin_readAttributes(self, attributes, expectedAttributes, stream, element, type)


    def writeAttributes(self, stream, type):
        """
        writeAttributes(MultiASTPlugin self, XMLOutputStream stream, int type)


        Internal implementation method.

        """
        return _libsbml.MultiASTPlugin_writeAttributes(self, stream, type)


    def writeXMLNS(self, stream):
        """
        writeXMLNS(MultiASTPlugin self, XMLOutputStream stream)


        Internal implementation method.

        """
        return _libsbml.MultiASTPlugin_writeXMLNS(self, stream)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(MultiASTPlugin self, string oldid, string newid)


        Renames the speciesReference SIdRef attribute on this node.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.MultiASTPlugin_renameSIdRefs(self, oldid, newid)

MultiASTPlugin_swigregister = _libsbml.MultiASTPlugin_swigregister
MultiASTPlugin_swigregister(MultiASTPlugin)

class QualPkgNamespaces(SBMLNamespaces):
    """

    Set of SBML Level + Version + namespace triples.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    SBMLExtensionNamespaces is a template class.  It is extended from
    SBMLNamespaces and is meant to be used by package extensions to store
    the SBML Level, Version within a Level, and package version of the
    SBML Level 3 package implemented by a libSBML package extension.

    Basic principles of SBML package extensions in libSBML
    ======================================================================

    SBML Level 3's package structure permits modular extensions to the
    core SBML format.  In libSBML, support for SBML Level 3 packages is
    provided through optional package extensions that can be plugged into
    libSBML at the time it is built/compiled.  Users of libSBML can thus
    choose which extensions are enabled in their software applications.

    LibSBML defines a number of classes that developers of package
    extensions can use to implement support for an SBML Level 3 package.
    These classes make it easier to extend libSBML objects with new
    attributes and/or subobjects as needed by a particular Level 3
    package. Three overall categories of classes make up libSBML's
    facilities for implementing package extensions.  There are (1) classes
    that serve as base classes meant to be subclassed, (2) template
    classes meant to be instantiated rather than subclassed, and (3)
    support classes that provide utility features. A given package
    implementation for libSBML will take the form of code using these and
    other libSBML classes, placed in a subdirectory of src/sbml/packages/.

    The basic libSBML distribution includes a number of package extensions
    implementing support for officially-endorsed SBML Level 3 packages;
    among these are Flux Balance Constraints ('fbc'), Hierarchical Model
    Composition ('comp'), Layout ('layout'), and Qualitative Models
    ('qual').  They can serve as working examples for developers working
    to implement other packages.

    Extensions in libSBML can currently only be implemented in C++ or C;
    there is no mechanism to implement them first in languages such as
    Java or Python.  However, once implemented in C++ or C, language
    interfaces can be generated semi-automatically using the framework in
    place in libSBML.  (The approach is based on using SWIG and facilities
    in libSBML's build system.)

    """

    __swig_setmethods__ = {}
    for _s in [SBMLNamespaces]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, QualPkgNamespaces, name, value)
    __swig_getmethods__ = {}
    for _s in [SBMLNamespaces]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, QualPkgNamespaces, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_QualPkgNamespaces
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(SBMLExtensionNamespaces<(QualExtension)> self, unsigned int level, unsigned int version, unsigned int pkgVersion, string prefix) -> QualPkgNamespaces
        __init__(SBMLExtensionNamespaces<(QualExtension)> self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> QualPkgNamespaces
        __init__(SBMLExtensionNamespaces<(QualExtension)> self, unsigned int level, unsigned int version) -> QualPkgNamespaces
        __init__(SBMLExtensionNamespaces<(QualExtension)> self, unsigned int level) -> QualPkgNamespaces
        __init__(SBMLExtensionNamespaces<(QualExtension)> self) -> QualPkgNamespaces
        __init__(SBMLExtensionNamespaces<(QualExtension)> self, QualPkgNamespaces orig) -> QualPkgNamespaces


        Set of SBML Level + Version + namespace triples.

        This class of objects is defined by libSBML only and has no direct
        equivalent in terms of SBML components.  This class is not prescribed
        by the SBML specifications, although it is used to implement features
        defined in SBML.

        SBMLExtensionNamespaces is a template class.  It is extended from
        SBMLNamespaces and is meant to be used by package extensions to store
        the SBML Level, Version within a Level, and package version of the
        SBML Level 3 package implemented by a libSBML package extension.

        Basic principles of SBML package extensions in libSBML
        ======================================================================

        SBML Level 3's package structure permits modular extensions to the
        core SBML format.  In libSBML, support for SBML Level 3 packages is
        provided through optional package extensions that can be plugged into
        libSBML at the time it is built/compiled.  Users of libSBML can thus
        choose which extensions are enabled in their software applications.

        LibSBML defines a number of classes that developers of package
        extensions can use to implement support for an SBML Level 3 package.
        These classes make it easier to extend libSBML objects with new
        attributes and/or subobjects as needed by a particular Level 3
        package. Three overall categories of classes make up libSBML's
        facilities for implementing package extensions.  There are (1) classes
        that serve as base classes meant to be subclassed, (2) template
        classes meant to be instantiated rather than subclassed, and (3)
        support classes that provide utility features. A given package
        implementation for libSBML will take the form of code using these and
        other libSBML classes, placed in a subdirectory of src/sbml/packages/.

        The basic libSBML distribution includes a number of package extensions
        implementing support for officially-endorsed SBML Level 3 packages;
        among these are Flux Balance Constraints ('fbc'), Hierarchical Model
        Composition ('comp'), Layout ('layout'), and Qualitative Models
        ('qual').  They can serve as working examples for developers working
        to implement other packages.

        Extensions in libSBML can currently only be implemented in C++ or C;
        there is no mechanism to implement them first in languages such as
        Java or Python.  However, once implemented in C++ or C, language
        interfaces can be generated semi-automatically using the framework in
        place in libSBML.  (The approach is based on using SWIG and facilities
        in libSBML's build system.)

        """
        this = _libsbml.new_QualPkgNamespaces(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(QualPkgNamespaces self) -> ISBMLExtensionNamespaces


        Creates and returns a deep copy of this SBMLNamespaces object.

        Returns the (deep) copy of this SBMLNamespaces object.

        """
        return _libsbml.QualPkgNamespaces_clone(self)


    def getURI(self):
        """
        getURI(QualPkgNamespaces self) -> string


        Returns a string representing the SBML XML namespace of this object.

        Returns a string representing the SBML namespace that reflects the
        SBML Level and Version of this object.

        """
        return _libsbml.QualPkgNamespaces_getURI(self)


    def getPackageVersion(self):
        """getPackageVersion(QualPkgNamespaces self) -> unsigned int"""
        return _libsbml.QualPkgNamespaces_getPackageVersion(self)


    def getPackageName(self):
        """
        getPackageName(QualPkgNamespaces self) -> string


        Returns the name of the main package for this namespace.

        Returns the name of the main package for this namespace. 'core' will
        be returned if this namespace is defined in the SBML  core.

        """
        return _libsbml.QualPkgNamespaces_getPackageName(self)

QualPkgNamespaces_swigregister = _libsbml.QualPkgNamespaces_swigregister
QualPkgNamespaces_swigregister(QualPkgNamespaces)

class QualExtension(SBMLExtension):
    """

    [SBML 'qual' package]

    Base extension class for the package.

    """

    __swig_setmethods__ = {}
    for _s in [SBMLExtension]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, QualExtension, name, value)
    __swig_getmethods__ = {}
    for _s in [SBMLExtension]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, QualExtension, name)
    __repr__ = _swig_repr

    def getPackageName():
        """
        getPackageName() -> string


        Returns the nickname of the SBML Level 3 package implemented by this
        libSBML extension.

        Returns the package nickname, as a string.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.QualExtension_getPackageName()

    getPackageName = staticmethod(getPackageName)

    def getDefaultLevel():
        """
        getDefaultLevel() -> unsigned int


        Returns the default SBML Level used by this libSBML package extension.

        Returns the SBML Level.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.QualExtension_getDefaultLevel()

    getDefaultLevel = staticmethod(getDefaultLevel)

    def getDefaultVersion():
        """
        getDefaultVersion() -> unsigned int


        Returns the default SBML Version used by this libSBML package
        extension.

        Returns the Version within the default SBML Level.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.QualExtension_getDefaultVersion()

    getDefaultVersion = staticmethod(getDefaultVersion)

    def getDefaultPackageVersion():
        """
        getDefaultPackageVersion() -> unsigned int


        Returns the default version of the SBML Level 3 package implemented by
        this libSBML extension.

        Returns the default version number of the SBML Level 3 package
        definition.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.QualExtension_getDefaultPackageVersion()

    getDefaultPackageVersion = staticmethod(getDefaultPackageVersion)

    def getXmlnsL3V1V1():
        """
        getXmlnsL3V1V1() -> string


        Returns the XML namespace URI of the SBML Level 3 package implemented
        by this libSBML extension.

        Returns the XML namespace as a string.

        Note: Because this is a static method on a class, the Python language
        interface for libSBML will contain two variants.  One will be the
        expected, normal static method on the class (i.e., a regular
        methodName), and the other will be a standalone top-level function
        with the name ClassName_methodName(). This is merely an artifact of
        how the language interfaces are created in libSBML.  The methods are
        functionally identical.

        """
        return _libsbml.QualExtension_getXmlnsL3V1V1()

    getXmlnsL3V1V1 = staticmethod(getXmlnsL3V1V1)

    def __init__(self, *args):
        """
        __init__(QualExtension self) -> QualExtension
        __init__(QualExtension self, QualExtension orig) -> QualExtension


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            QualExtension(QualExtension orig)

        Copy constructor.

        Parameter 'orig' is the instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            QualExtension()

        Creates a new QualExtension instance.

        """
        this = _libsbml.new_QualExtension(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_QualExtension
    __del__ = lambda self: None

    def clone(self):
        """
        clone(QualExtension self) -> QualExtension


        Creates and returns a deep copy of this QualExtension object.

        Returns a (deep) copy of this SBase object.

        """
        return _libsbml.QualExtension_clone(self)


    def getName(self):
        """
        getName(QualExtension self) -> string


        Returns the name of this package ('qual')

        Returns a string representing the name of this package ('qual').

        """
        return _libsbml.QualExtension_getName(self)


    def getURI(self, sbmlLevel, sbmlVersion, pkgVersion):
        """
        getURI(QualExtension self, unsigned int sbmlLevel, unsigned int sbmlVersion, unsigned int pkgVersion) -> string


        Returns a string representing the SBML XML namespace of this SBML
        Level 3 package.

        The namespace URI constructed by this method corresponds to the
        combination of the Level and Version of SBML, and the Version of the
        SBML Level 3 package. (At the time of this writing, the only SBML
        Level that supports packages is Level 3, so the value of 'sbmlLevel'
        must necessarily always be 3.)

        Parameter 'sbmlLevel' is the level of SBML. Parameter 'sbmlVersion' is
        the version of SBML. Parameter 'pkgVersion' is the version of the
        package.

        Returns a string of the package URI, or an empty string if no
        corresponding URI exists.

        """
        return _libsbml.QualExtension_getURI(self, sbmlLevel, sbmlVersion, pkgVersion)


    def getLevel(self, uri):
        """
        getLevel(QualExtension self, string uri) -> unsigned int


        Returns the SBML Level for the given URI of this package.

        Parameter 'uri' is a URI that represents a version of this package.

        Returns the SBML Level for the given URI of this package, or '0' if
        the given URI is invalid, or for a different package.

        """
        return _libsbml.QualExtension_getLevel(self, uri)


    def getVersion(self, uri):
        """
        getVersion(QualExtension self, string uri) -> unsigned int


        Returns the Version within the SBML Level for the given URI of this
        package.

        Parameter 'uri' is a URI that represents a version of this package.

        Returns the SBML Version within the SBML Level for the given URI of
        this package, or '0' if the given URI is invalid, or for a different
        package.

        """
        return _libsbml.QualExtension_getVersion(self, uri)


    def getPackageVersion(self, uri):
        """
        getPackageVersion(QualExtension self, string uri) -> unsigned int


        Returns the SBML Level 3 package version for the given URI of this
        package.

        Parameter 'uri' is a URI that represents one of the valid versions of
        this package.

        Returns the version of the SBML Level 3 package with the given URI, or
        '0' if the given URI is invalid, or for a different package.

        """
        return _libsbml.QualExtension_getPackageVersion(self, uri)


    def getSBMLExtensionNamespaces(self, uri):
        """
        getSBMLExtensionNamespaces(QualExtension self, string uri) -> SBMLNamespaces


        Returns a QualPkgNamespaces object.

        Parameter 'uri' is a URI that represents one of the valid versions of
        the "qual" package.

        Returns a QualPkgNamespaces object corresponding to the given 'uri',
        or 'None' if the URI is not defined in the Qual package.

        """
        return _libsbml.QualExtension_getSBMLExtensionNamespaces(self, uri)


    def getStringFromTypeCode(self, typeCode):
        """
        getStringFromTypeCode(QualExtension self, int typeCode) -> char const *


        Takes a type code of the "qual" package and returns a string
        describing the code.

        Parameter 'typeCode' is a libSBML type code defined by the libSBML
        extension implementing support for the SBML Level 3 "qual" package.

        Returns a text string representing the type code given by 'typeCode'.
        If the type code is unrecognized for this implementation of the
        libSBML "qual" package, the string returned will be '(Unknown SBML
        Qual Type)'.

        """
        return _libsbml.QualExtension_getStringFromTypeCode(self, typeCode)


    def init():
        """
        init()


        Internal implementation method.

        """
        return _libsbml.QualExtension_init()

    init = staticmethod(init)

    def getErrorTable(self, index):
        """
        getErrorTable(QualExtension self, unsigned int index) -> packageErrorTableEntry


        Internal implementation method.

        """
        return _libsbml.QualExtension_getErrorTable(self, index)


    def getErrorTableIndex(self, errorId):
        """
        getErrorTableIndex(QualExtension self, unsigned int errorId) -> unsigned int


        Internal implementation method.

        """
        return _libsbml.QualExtension_getErrorTableIndex(self, errorId)


    def getErrorIdOffset(self):
        """
        getErrorIdOffset(QualExtension self) -> unsigned int


        Internal implementation method.

        """
        return _libsbml.QualExtension_getErrorIdOffset(self)

QualExtension_swigregister = _libsbml.QualExtension_swigregister
QualExtension_swigregister(QualExtension)

def QualExtension_getPackageName():
    """
    QualExtension_getPackageName() -> string


    Returns the nickname of the SBML Level 3 package implemented by this
    libSBML extension.

    Returns the package nickname, as a string.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.QualExtension_getPackageName()

def QualExtension_getDefaultLevel():
    """
    QualExtension_getDefaultLevel() -> unsigned int


    Returns the default SBML Level used by this libSBML package extension.

    Returns the SBML Level.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.QualExtension_getDefaultLevel()

def QualExtension_getDefaultVersion():
    """
    QualExtension_getDefaultVersion() -> unsigned int


    Returns the default SBML Version used by this libSBML package
    extension.

    Returns the Version within the default SBML Level.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.QualExtension_getDefaultVersion()

def QualExtension_getDefaultPackageVersion():
    """
    QualExtension_getDefaultPackageVersion() -> unsigned int


    Returns the default version of the SBML Level 3 package implemented by
    this libSBML extension.

    Returns the default version number of the SBML Level 3 package
    definition.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.QualExtension_getDefaultPackageVersion()

def QualExtension_getXmlnsL3V1V1():
    """
    QualExtension_getXmlnsL3V1V1() -> string


    Returns the XML namespace URI of the SBML Level 3 package implemented
    by this libSBML extension.

    Returns the XML namespace as a string.

    Note: Because this is a static method on a class, the Python language
    interface for libSBML will contain two variants.  One will be the
    expected, normal static method on the class (i.e., a regular
    methodName), and the other will be a standalone top-level function
    with the name ClassName_methodName(). This is merely an artifact of
    how the language interfaces are created in libSBML.  The methods are
    functionally identical.

    """
    return _libsbml.QualExtension_getXmlnsL3V1V1()

def QualExtension_init():
    """
    QualExtension_init()


    Internal implementation method.

    """
    return _libsbml.QualExtension_init()

SBML_QUAL_QUALITATIVE_SPECIES = _libsbml.SBML_QUAL_QUALITATIVE_SPECIES
SBML_QUAL_TRANSITION = _libsbml.SBML_QUAL_TRANSITION
SBML_QUAL_INPUT = _libsbml.SBML_QUAL_INPUT
SBML_QUAL_OUTPUT = _libsbml.SBML_QUAL_OUTPUT
SBML_QUAL_FUNCTION_TERM = _libsbml.SBML_QUAL_FUNCTION_TERM
SBML_QUAL_DEFAULT_TERM = _libsbml.SBML_QUAL_DEFAULT_TERM
class QualModelPlugin(SBasePlugin):
    """

    [SBML 'qual' package]

    Extension of Model.

    The extension of SBML Level 3 Core's Model class is relatively
    straightforward: the Qualitative Models Package adds two lists, one
    for holding qualitativeSpecies (ListOfQualitativeSpecies), and the
    other for holding transitions (ListOfTransitions).  The Model element
    may contain at most one ListOfQualitativeSpecies, which must contain
    at least one QualitativeSpecies. It may also contain at most one
    ListOfTransitions which must contain at least one Transition.

    """

    __swig_setmethods__ = {}
    for _s in [SBasePlugin]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, QualModelPlugin, name, value)
    __swig_getmethods__ = {}
    for _s in [SBasePlugin]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, QualModelPlugin, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(QualModelPlugin self, string uri, string prefix, QualPkgNamespaces qualns) -> QualModelPlugin
        __init__(QualModelPlugin self, QualModelPlugin orig) -> QualModelPlugin


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            QualModelPlugin(QualModelPlugin orig)

        Copy constructor. Creates a copy of this object.

        Parameter 'orig' is the instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            QualModelPlugin(string &uri, string &prefix,
        QualPkgNamespaces qualns)

        Creates a new QualModelPlugin object using the given parameters.

        In the XML representation of an SBML document, XML namespaces are
        used to identify the origin of each XML construct used.  XML
        namespaces are identified by their unique resource identifiers (URIs).
        The core SBML specifications stipulate the namespaces that must be
        used for core SBML constructs; for example, all XML elements that
        belong to SBML Level 3 Version 1 Core must be placed in the XML
        namespace identified by the URI
        'http://www.sbml.org/sbml/level3/version1/core'.  Individual SBML
        Level 3 packages define their own XML namespaces; for example, all
        elements belonging to the SBML Level 3 Layout Version 1 package must
        be placed in the XML namespace
        'http://www.sbml.org/sbml/level3/version1/layout/version1/'.

        The SBMLNamespaces object encapsulates SBML Level/Version/namespaces
        information.  It is used to communicate the SBML Level, Version, and
        (in Level 3) packages used in addition to SBML Level 3 Core.  A common
        approach to using libSBML's SBMLNamespaces facilities is to create an
        SBMLNamespaces object somewhere in a program once, then hand that
        object as needed to object constructors that accept SBMLNamespaces as
        arguments.

        Parameter 'uri' is the URI of the SBML Level 3 package implemented by
        this libSBML package extension.

        Parameter 'prefix' is the XML namespace prefix being used for the
        package.

        Parameter 'qualns' is the namespaces object for the package.

        """
        this = _libsbml.new_QualModelPlugin(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_QualModelPlugin
    __del__ = lambda self: None

    def clone(self):
        """
        clone(QualModelPlugin self) -> QualModelPlugin


        Creates and returns a deep copy of this QualModelPlugin object.

        Returns a (deep) copy of this QualModelPlugin object.

        """
        return _libsbml.QualModelPlugin_clone(self)


    def createObject(self, stream):
        """
        createObject(QualModelPlugin self, XMLInputStream stream) -> SBase


        Internal implementation method.

        """
        return _libsbml.QualModelPlugin_createObject(self, stream)


    def appendFrom(self, model):
        """
        appendFrom(QualModelPlugin self, Model model) -> int


        Internal implementation method.

        """
        return _libsbml.QualModelPlugin_appendFrom(self, model)


    def getListOfQualitativeSpecies(self, *args):
        """
        getListOfQualitativeSpecies(QualModelPlugin self) -> ListOfQualitativeSpecies
        getListOfQualitativeSpecies(QualModelPlugin self) -> ListOfQualitativeSpecies


        Returns the ListOfQualitativeSpecies in this plugin object.

        Returns ListOfQualitativeSpecies object in this plugin object.

        """
        return _libsbml.QualModelPlugin_getListOfQualitativeSpecies(self, *args)


    def getQualitativeSpecies(self, *args):
        """
        getQualitativeSpecies(QualModelPlugin self, unsigned int n) -> QualitativeSpecies
        getQualitativeSpecies(QualModelPlugin self, unsigned int n) -> QualitativeSpecies
        getQualitativeSpecies(QualModelPlugin self, string sid) -> QualitativeSpecies
        getQualitativeSpecies(QualModelPlugin self, string sid) -> QualitativeSpecies


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getQualitativeSpecies(long n)

        Returns the QualitativeSpecies object that belongs to the given index.
        If the index is invalid, None is returned.

        Parameter 'n' is the index number of the QualitativeSpecies to get.

        Returns the nth QualitativeSpecies in the ListOfQualitativeSpecies. If
        the index 'n' is invalid, 'None' is returned.

        ______________________________________________________________________
        Method variant with the following signature:

            getQualitativeSpecies(string sid)

        Returns the qualitativeSpecies object based on its identifier.

        Parameter 'sid' is a string representing the identifier  of the
        QualitativeSpecies to get.

        Returns QualitativeSpecies in the ListOfQualitativeSpecies with the
        given id  or 'None' if no such QualitativeSpecies exists.

        See also getQualitativeSpecies(), getListOfQualitativeSpecies().

        """
        return _libsbml.QualModelPlugin_getQualitativeSpecies(self, *args)


    def addQualitativeSpecies(self, qualitativeSpecies):
        """
        addQualitativeSpecies(QualModelPlugin self, QualitativeSpecies qualitativeSpecies) -> int


        Adds a copy of the given QualitativeSpecies object to the list of
        qual.

        Parameter 'qualitativeSpecies' is the QualitativeSpecies object to be
        added to the list of qual.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.QualModelPlugin_addQualitativeSpecies(self, qualitativeSpecies)


    def createQualitativeSpecies(self):
        """
        createQualitativeSpecies(QualModelPlugin self) -> QualitativeSpecies


        Creates a new qual object and adds it to the list of qual objects and
        returns it.

        Returns a newly created QualitativeSpecies object.

        """
        return _libsbml.QualModelPlugin_createQualitativeSpecies(self)


    def removeQualitativeSpecies(self, *args):
        """
        removeQualitativeSpecies(QualModelPlugin self, unsigned int n) -> QualitativeSpecies
        removeQualitativeSpecies(QualModelPlugin self, string sid) -> QualitativeSpecies


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeQualitativeSpecies(long n)

        Removes the nth QualitativeSpecies object from this plugin object and
        returns a pointer to it.

        The caller owns the returned object and is responsible for deleting
        it.

        Parameter 'n' is the index of the QualitativeSpecies object to remove.

        Returns the QualitativeSpecies object removed.  As mentioned above,
        the  caller owns the returned object. None is returned if the  given
        index is out of range.

        ______________________________________________________________________
        Method variant with the following signature:

            removeQualitativeSpecies(string sid)

        Removes the QualitativeSpecies object with the given id attribute from
        this plugin object and returns a pointer to it.

        The caller owns the returned object and is responsible for deleting
        it.

        Parameter 'sid' is the id attribute of the QualitativeSpecies object
        to remove.

        Returns the QualitativeSpecies object removed.  As mentioned above,
        the  caller owns the returned object. None is returned if the  given
        index is out of range.

        """
        return _libsbml.QualModelPlugin_removeQualitativeSpecies(self, *args)


    def getNumQualitativeSpecies(self):
        """
        getNumQualitativeSpecies(QualModelPlugin self) -> unsigned int


        Returns the number of QualitativeSpecies object in this plugin object.

        Returns the number of QualitativeSpecies object in this plugin object.

        """
        return _libsbml.QualModelPlugin_getNumQualitativeSpecies(self)


    def getListOfTransitions(self, *args):
        """
        getListOfTransitions(QualModelPlugin self) -> ListOfTransitions
        getListOfTransitions(QualModelPlugin self) -> ListOfTransitions


        Returns the ListOfTransitions in this plugin object.

        Returns ListOfTransitions object in this plugin object.

        """
        return _libsbml.QualModelPlugin_getListOfTransitions(self, *args)


    def getTransition(self, *args):
        """
        getTransition(QualModelPlugin self, unsigned int n) -> Transition
        getTransition(QualModelPlugin self, unsigned int n) -> Transition
        getTransition(QualModelPlugin self, string sid) -> Transition
        getTransition(QualModelPlugin self, string sid) -> Transition


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getTransition(long n)

        Returns the Transition object that belongs to the given index. If the
        index is invalid, None is returned.

        Parameter 'n' is the index number of the Transition to get.

        Returns the nth Transition in the ListOfTransitions. If the index 'n'
        is invalid, 'None' is returned.

        ______________________________________________________________________
        Method variant with the following signature:

            getTransition(string sid)

        Returns the qualitativeSpecies object based on its identifier.

        Parameter 'sid' is a string representing the identifier  of the
        Transition to get.

        Returns Transition in the ListOfTransitions with the given id  or
        'None' if no such Transition exists.

        See also getTransition(), getListOfTransitions().

        """
        return _libsbml.QualModelPlugin_getTransition(self, *args)


    def addTransition(self, transition):
        """
        addTransition(QualModelPlugin self, Transition transition) -> int


        Adds a copy of the given Transition object to the list of qual.

        Parameter 'transition' is the Transition object to be added to the
        list of qual.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.QualModelPlugin_addTransition(self, transition)


    def createTransition(self):
        """
        createTransition(QualModelPlugin self) -> Transition


        Creates a new qual object and adds it to the list of qual objects and
        returns it.

        Returns a newly created Transition object.

        """
        return _libsbml.QualModelPlugin_createTransition(self)


    def removeTransition(self, *args):
        """
        removeTransition(QualModelPlugin self, unsigned int n) -> Transition
        removeTransition(QualModelPlugin self, string sid) -> Transition


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeTransition(long n)

        Removes the nth Transition object from this plugin object and returns
        a pointer to it.

        The caller owns the returned object and is responsible for deleting
        it.

        Parameter 'n' is the index of the Transition object to remove.

        Returns the Transition object removed.  As mentioned above, the
        caller owns the returned object. None is returned if the  given index
        is out of range.

        ______________________________________________________________________
        Method variant with the following signature:

            removeTransition(string sid)

        Removes the Transition object with the given id attribute from  this
        plugin object and returns a pointer to it.

        The caller owns the returned object and is responsible for deleting
        it.

        Parameter 'sid' is the id attribute of the Transition object to
        remove.

        Returns the Transition object removed.  As mentioned above, the
        caller owns the returned object. None is returned if the  given index
        is out of range.

        """
        return _libsbml.QualModelPlugin_removeTransition(self, *args)


    def getNumTransitions(self):
        """
        getNumTransitions(QualModelPlugin self) -> unsigned int


        Returns the number of Transition object in this plugin object.

        Returns the number of Transition object in this plugin object.

        """
        return _libsbml.QualModelPlugin_getNumTransitions(self)


    def connectToChild(self):
        """
        connectToChild(QualModelPlugin self)


        Internal implementation method.

        """
        return _libsbml.QualModelPlugin_connectToChild(self)


    def connectToParent(self, sbase):
        """
        connectToParent(QualModelPlugin self, SBase sbase)


        Internal implementation method.

        """
        return _libsbml.QualModelPlugin_connectToParent(self, sbase)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(QualModelPlugin self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.QualModelPlugin_enablePackageInternal(self, pkgURI, pkgPrefix, flag)


    def getElementBySId(self, id):
        """
        getElementBySId(QualModelPlugin self, string id) -> SBase


        Returns the first child element that has the given 'id' in the model-
        wide SId namespace, or 'None' if no such object is found.

        Parameter 'id' is a string representing the id attribute of the object
        to retrieve.

        Returns a pointer to the SBase element with the given 'id'.

        """
        return _libsbml.QualModelPlugin_getElementBySId(self, id)


    def getElementByMetaId(self, metaid):
        """
        getElementByMetaId(QualModelPlugin self, string metaid) -> SBase


        Returns the first child element that has the given 'metaid', or 'None'
        if no such object is found.

        Parameter 'metaid' is a string representing the metaid attribute of
        the object to retrieve.

        Returns a pointer to the SBase element with the given 'metaid'.

        """
        return _libsbml.QualModelPlugin_getElementByMetaId(self, metaid)

QualModelPlugin_swigregister = _libsbml.QualModelPlugin_swigregister
QualModelPlugin_swigregister(QualModelPlugin)

class FunctionTerm(SBase):
    """

    [SBML 'qual' package]

    A function term.

    Each FunctionTerm is associated with a result and with a Boolean
    function inside a Math element that can be used to set the conditions
    under which this term is selected.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FunctionTerm, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, FunctionTerm, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(FunctionTerm self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> FunctionTerm
        __init__(FunctionTerm self, unsigned int level, unsigned int version) -> FunctionTerm
        __init__(FunctionTerm self, unsigned int level) -> FunctionTerm
        __init__(FunctionTerm self) -> FunctionTerm
        __init__(FunctionTerm self, QualPkgNamespaces qualns) -> FunctionTerm
        __init__(FunctionTerm self, FunctionTerm orig) -> FunctionTerm


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            FunctionTerm(long level      =
        QualExtension.getDefaultLevel(), long version    =
        QualExtension.getDefaultVersion(), long pkgVersion =
        QualExtension.getDefaultPackageVersion())

        Creates a new FunctionTerm with the given level, version, and package
        version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        FunctionTerm.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this FunctionTerm.

        Parameter 'pkgVersion' is a long integer, the SBML Qual Version to
        assign to this FunctionTerm.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            FunctionTerm(FunctionTerm orig)

        Copy constructor for FunctionTerm.

        Parameter 'orig' is the FunctionTerm instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            FunctionTerm(QualPkgNamespaces qualns)

        Creates a new FunctionTerm with the given QualPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'qualns' is the QualPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_FunctionTerm(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(FunctionTerm self) -> FunctionTerm


        Creates and returns a deep copy of this FunctionTerm object.

        Returns a (deep) copy of this FunctionTerm object.

        """
        return _libsbml.FunctionTerm_clone(self)

    __swig_destroy__ = _libsbml.delete_FunctionTerm
    __del__ = lambda self: None

    def getResultLevel(self):
        """
        getResultLevel(FunctionTerm self) -> int


        Returns the value of the 'resultLevel' attribute of this FunctionTerm.

        Returns the value of the 'resultLevel' attribute of this FunctionTerm
        as a integer.

        """
        return _libsbml.FunctionTerm_getResultLevel(self)


    def isSetResultLevel(self):
        """
        isSetResultLevel(FunctionTerm self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        FunctionTerm's 'resultLevel' attribute has been set.

        Returns 'True' if this FunctionTerm's 'resultLevel' attribute has been
        set, otherwise 'False' is returned.

        """
        return _libsbml.FunctionTerm_isSetResultLevel(self)


    def setResultLevel(self, resultLevel):
        """
        setResultLevel(FunctionTerm self, int resultLevel) -> int


        Sets the value of the 'resultLevel' attribute of this FunctionTerm.

        Parameter 'resultLevel' is int value of the 'resultLevel' attribute to
        be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.FunctionTerm_setResultLevel(self, resultLevel)


    def unsetResultLevel(self):
        """
        unsetResultLevel(FunctionTerm self) -> int


        Unsets the value of the 'resultLevel' attribute of this FunctionTerm.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.FunctionTerm_unsetResultLevel(self)


    def getMath(self):
        """
        getMath(FunctionTerm self) -> ASTNode


        Returns the 'math' element of this FunctionTerm.

        Returns the 'math' element of this FunctionTerm, or 'None' if the math
        is not set.

        """
        return _libsbml.FunctionTerm_getMath(self)


    def isSetMath(self):
        """
        isSetMath(FunctionTerm self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        FunctionTerm's 'math' element has been set.

        Returns 'True' if this FunctionTerm's 'math' element has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.FunctionTerm_isSetMath(self)


    def setMath(self, math):
        """
        setMath(FunctionTerm self, ASTNode math) -> int


        Sets the 'math' element of this FunctionTerm.

        Parameter 'math' is ASTNode  math of the 'resultLevel' attribute to be
        set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.FunctionTerm_setMath(self, math)


    def unsetMath(self):
        """
        unsetMath(FunctionTerm self) -> int


        Unsets the 'math' element of this FunctionTerm.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.FunctionTerm_unsetMath(self)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(FunctionTerm self, string oldid, string newid)


        Replaces all uses of a given 'SIdRef' type attribute value with
        another value.

        In SBML, object identifiers are of a data type called SId. In SBML
        Level 3, an explicit data type called SIdRef was introduced for
        attribute values that refer to SId values; in previous Levels of SBML,
        this data type did not exist and attributes were simply described to
        as 'referring to an identifier', but the effective data type was the
        same as SIdRef in Level 3.  These and other methods of libSBML refer
        to the type SIdRef for all Levels of SBML, even if the corresponding
        SBML specification did not explicitly name the data type.

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas in MathML content, comparing the referenced
        identifiers to the value of 'oldid'.  If any matches are found, the
        matching values are replaced with 'newid'.  The method does not
        descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.FunctionTerm_renameSIdRefs(self, oldid, newid)


    def getElementName(self):
        """
        getElementName(FunctionTerm self) -> string


        Returns the XML name of this object.

        Returns the name of this element.

        """
        return _libsbml.FunctionTerm_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(FunctionTerm self) -> int


        Returns the libSBML type code of this object instance.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_QUAL_FUNCTION_TERM

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.FunctionTerm_getTypeCode(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(FunctionTerm self) -> bool


        Predicate returning 'True' if all the required attributes for this
        FunctionTerm object have been set.

        Note: The required attributes for a FunctionTerm object are:

        Returns a boolean value indicating whether all the required attributes
        for this object have been defined.

        """
        return _libsbml.FunctionTerm_hasRequiredAttributes(self)


    def hasRequiredElements(self):
        """
        hasRequiredElements(FunctionTerm self) -> bool


        Predicate returning 'True' if all the required elements for this
        FunctionTerm object have been set.

        Note: The required elements for a FunctionTerm object are:

        * 'math'

        Returns a boolean value indicating whether all the required elements
        for this object have been defined.

        """
        return _libsbml.FunctionTerm_hasRequiredElements(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(FunctionTerm self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.FunctionTerm_enablePackageInternal(self, pkgURI, pkgPrefix, flag)

FunctionTerm_swigregister = _libsbml.FunctionTerm_swigregister
FunctionTerm_swigregister(FunctionTerm)

class ListOfFunctionTerms(ListOf):
    """

    [SBML 'qual' package]

    A list of FunctionTerm objects.

    The ListOfFunctionTerms is a container for the FunctionTerms of a
    Transition.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    See also Input.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfFunctionTerms, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfFunctionTerms, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ListOfFunctionTerms self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ListOfFunctionTerms
        __init__(ListOfFunctionTerms self, unsigned int level, unsigned int version) -> ListOfFunctionTerms
        __init__(ListOfFunctionTerms self, unsigned int level) -> ListOfFunctionTerms
        __init__(ListOfFunctionTerms self) -> ListOfFunctionTerms
        __init__(ListOfFunctionTerms self, QualPkgNamespaces qualns) -> ListOfFunctionTerms
        __init__(ListOfFunctionTerms self, ListOfFunctionTerms orig) -> ListOfFunctionTerms


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfFunctionTerms(ListOfFunctionTerms orig)

        Creates a new ListOfFunctionTerms from the original.

        Parameter 'orig' is the ListOfFunctionTerms object.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfFunctionTerms(long level      =
        QualExtension.getDefaultLevel(), long version    =
        QualExtension.getDefaultVersion(), long pkgVersion =
        QualExtension.getDefaultPackageVersion())

        Creates a new ListOfFunctionTerms with the given level, version, and
        package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        ListOfFunctionTerms.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this ListOfFunctionTerms.

        Parameter 'pkgVersion' is a long integer, the SBML Qual Version to
        assign to this ListOfFunctionTerms.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfFunctionTerms(QualPkgNamespaces qualns)

        Creates a new ListOfFunctionTerms with the given QualPkgNamespaces
        object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'qualns' is the QualPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_ListOfFunctionTerms(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ListOfFunctionTerms self) -> ListOfFunctionTerms


        Creates and returns a deep copy of this ListOfFunctionTerms object.

        Returns a (deep) copy of this ListOfFunctionTerms object.

        """
        return _libsbml.ListOfFunctionTerms_clone(self)

    __swig_destroy__ = _libsbml.delete_ListOfFunctionTerms
    __del__ = lambda self: None

    def get(self, *args):
        """
        get(ListOfFunctionTerms self, unsigned int n) -> FunctionTerm
        get(ListOfFunctionTerms self, unsigned int n) -> FunctionTerm
        get(ListOfFunctionTerms self, string sid) -> FunctionTerm
        get(ListOfFunctionTerms self, string sid) -> FunctionTerm


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a FunctionTerm from the ListOfFunctionTerms.

        Parameter 'n' is the index number of the FunctionTerm to get.

        Returns the nth FunctionTerm in this ListOfFunctionTerms. If the index
        'n' is invalid, 'None' is returned.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a FunctionTerm from the ListOfFunctionTerms based on its
        identifier.

        Parameter 'sid' is a string representing the identifier of the
        FunctionTerm to get.

        Returns FunctionTerm in this ListOfFunctionTerms with the given id or
        'None' if no such FunctionTerm exists.

        See also get()   *, size().

        """
        return _libsbml.ListOfFunctionTerms_get(self, *args)


    def remove(self, *args):
        """
        remove(ListOfFunctionTerms self, unsigned int n) -> FunctionTerm
        remove(ListOfFunctionTerms self, string sid) -> FunctionTerm


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth FunctionTerm from this ListOfFunctionTerms and returns
        a pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the FunctionTerm to remove.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes the FunctionTerm from this ListOfFunctionTerms with the given
        identifier and returns a pointer to it.

        The caller owns the returned item and is responsible for deleting it.
        If none of the items in this list have the identifier 'sid', then
        'None' is returned.

        Parameter 'sid' is the identifier of the FunctionTerm to remove.

        Returns the FunctionTerm removed. As mentioned above, the caller owns
        the returned item.

        """
        return _libsbml.ListOfFunctionTerms_remove(self, *args)


    def getElementName(self):
        """
        getElementName(ListOfFunctionTerms self) -> string


        Returns the XML name of this object.

        Returns the name of this element.

        """
        return _libsbml.ListOfFunctionTerms_getElementName(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfFunctionTerms self) -> int


        Returns the libSBML type code for the SBML objects contained in this
        ListOf object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for objects contained in this list:
        SBML_QUAL_FUNCTION_TERM (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfFunctionTerms_getItemTypeCode(self)


    def getDefaultTerm(self, *args):
        """
        getDefaultTerm(ListOfFunctionTerms self) -> DefaultTerm
        getDefaultTerm(ListOfFunctionTerms self) -> DefaultTerm


        Get the DefaultTerm from this ListOfFunctionTerms.

        Returns the DefaultTerm in this ListOfFunctionTerms, or 'None' if no
        such value is set.

        See also Transition::getDefaultTerm.

        """
        return _libsbml.ListOfFunctionTerms_getDefaultTerm(self, *args)


    def setDefaultTerm(self, dt):
        """
        setDefaultTerm(ListOfFunctionTerms self, DefaultTerm dt) -> int


        Sets the given DefaultTerm to this Transition.

        Parameter 'dt' is the DefaultTerm object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.ListOfFunctionTerms_setDefaultTerm(self, dt)


    def isSetDefaultTerm(self):
        """
        isSetDefaultTerm(ListOfFunctionTerms self) -> bool


        Predicate returning 'True' if the defaultTerm  for this
        ListOfFunctionTerms object has been set.

        Returns a boolean value indicating whether the defaultTerm child for
        this object has been defined.

        """
        return _libsbml.ListOfFunctionTerms_isSetDefaultTerm(self)


    def createDefaultTerm(self):
        """
        createDefaultTerm(ListOfFunctionTerms self) -> DefaultTerm


        Creates a new DefaultTerm object, adds it to this ListOfFunctionTerms
        and returns the DefaultTerm object created.

        Returns a new DefaultTerm object instance.

        See also setDefaultTerm().

        """
        return _libsbml.ListOfFunctionTerms_createDefaultTerm(self)

ListOfFunctionTerms_swigregister = _libsbml.ListOfFunctionTerms_swigregister
ListOfFunctionTerms_swigregister(ListOfFunctionTerms)

class DefaultTerm(SBase):
    """

    [SBML 'qual' package]

    The default result of a Transition.

    The DefaultTerm defines the default result of a Transition, held in
    the (required) 'resultLevel' attribute.  This term is used when there
    are no other FunctionTerm elements or when none of the Math elements
    of the FunctionTerm elements evaluate to 'True.'

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DefaultTerm, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, DefaultTerm, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(DefaultTerm self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> DefaultTerm
        __init__(DefaultTerm self, unsigned int level, unsigned int version) -> DefaultTerm
        __init__(DefaultTerm self, unsigned int level) -> DefaultTerm
        __init__(DefaultTerm self) -> DefaultTerm
        __init__(DefaultTerm self, QualPkgNamespaces qualns) -> DefaultTerm
        __init__(DefaultTerm self, DefaultTerm orig) -> DefaultTerm


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            DefaultTerm(long level      =
        QualExtension.getDefaultLevel(), long version    =
        QualExtension.getDefaultVersion(), long pkgVersion =
        QualExtension.getDefaultPackageVersion())

        Creates a new DefaultTerm with the given level, version, and package
        version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        DefaultTerm.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this DefaultTerm.

        Parameter 'pkgVersion' is a long integer, the SBML Qual Version to
        assign to this DefaultTerm.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            DefaultTerm(DefaultTerm orig)

        Copy constructor for DefaultTerm.

        Parameter 'orig' is the DefaultTerm instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            DefaultTerm(QualPkgNamespaces qualns)

        Creates a new DefaultTerm with the given QualPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'qualns' is the QualPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_DefaultTerm(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(DefaultTerm self) -> DefaultTerm


        Creates and returns a deep copy of this DefaultTerm object.

        Returns a (deep) copy of this DefaultTerm object.

        """
        return _libsbml.DefaultTerm_clone(self)

    __swig_destroy__ = _libsbml.delete_DefaultTerm
    __del__ = lambda self: None

    def getResultLevel(self):
        """
        getResultLevel(DefaultTerm self) -> int


        Returns the value of the 'resultLevel' attribute of this DefaultTerm.

        Returns the value of the 'resultLevel' attribute of this DefaultTerm
        as a integer.

        """
        return _libsbml.DefaultTerm_getResultLevel(self)


    def isSetResultLevel(self):
        """
        isSetResultLevel(DefaultTerm self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        DefaultTerm's 'resultLevel' attribute has been set.

        Returns 'True' if this DefaultTerm's 'resultLevel' attribute has been
        set, otherwise 'False' is returned.

        """
        return _libsbml.DefaultTerm_isSetResultLevel(self)


    def setResultLevel(self, resultLevel):
        """
        setResultLevel(DefaultTerm self, int resultLevel) -> int


        Sets the value of the 'resultLevel' attribute of this DefaultTerm.

        Parameter 'resultLevel' is int value of the 'resultLevel' attribute to
        be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.DefaultTerm_setResultLevel(self, resultLevel)


    def unsetResultLevel(self):
        """
        unsetResultLevel(DefaultTerm self) -> int


        Unsets the value of the 'resultLevel' attribute of this DefaultTerm.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.DefaultTerm_unsetResultLevel(self)


    def getElementName(self):
        """
        getElementName(DefaultTerm self) -> string


        Returns the XML name of this object.

        Returns the name of this element.

        """
        return _libsbml.DefaultTerm_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(DefaultTerm self) -> int


        Returns the libSBML type code of this object instance.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_QUAL_DEFAULT_TERM.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.DefaultTerm_getTypeCode(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(DefaultTerm self) -> bool


        Predicate returning 'True' if all the required attributes for this
        DefaultTerm object have been set.

        Note: The required attribute for a DefaultTerm object is:

        * 'resultLevel'

        Returns a boolean value indicating whether the required attribute for
        this object has been defined.

        """
        return _libsbml.DefaultTerm_hasRequiredAttributes(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(DefaultTerm self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.DefaultTerm_enablePackageInternal(self, pkgURI, pkgPrefix, flag)

DefaultTerm_swigregister = _libsbml.DefaultTerm_swigregister
DefaultTerm_swigregister(DefaultTerm)

INPUT_TRANSITION_EFFECT_NONE = _libsbml.INPUT_TRANSITION_EFFECT_NONE
INPUT_TRANSITION_EFFECT_CONSUMPTION = _libsbml.INPUT_TRANSITION_EFFECT_CONSUMPTION
INPUT_TRANSITION_EFFECT_UNKNOWN = _libsbml.INPUT_TRANSITION_EFFECT_UNKNOWN
INPUT_SIGN_POSITIVE = _libsbml.INPUT_SIGN_POSITIVE
INPUT_SIGN_NEGATIVE = _libsbml.INPUT_SIGN_NEGATIVE
INPUT_SIGN_DUAL = _libsbml.INPUT_SIGN_DUAL
INPUT_SIGN_UNKNOWN = _libsbml.INPUT_SIGN_UNKNOWN
INPUT_SIGN_VALUE_NOTSET = _libsbml.INPUT_SIGN_VALUE_NOTSET
class Input(SBase):
    """

    [SBML 'qual' package]

    The input to a QualitativeSpecies.

    Each Input refers to a QualitativeSpecies that participates in the
    corresponding Transition. In Petri nets, these are the input places of
    the transition. In logical models, they are the regulators of the
    species whose behaviour is defined by the transition.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Input, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Input, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(Input self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> Input
        __init__(Input self, unsigned int level, unsigned int version) -> Input
        __init__(Input self, unsigned int level) -> Input
        __init__(Input self) -> Input
        __init__(Input self, QualPkgNamespaces qualns) -> Input
        __init__(Input self, Input orig) -> Input


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            Input(long level      = QualExtension.getDefaultLevel(), long
        version    = QualExtension.getDefaultVersion(), long pkgVersion =
        QualExtension.getDefaultPackageVersion())

        Creates a new Input with the given level, version, and package
        version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        Input.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this Input.

        Parameter 'pkgVersion' is a long integer, the SBML Qual Version to
        assign to this Input.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            Input(Input orig)

        Copy constructor for Input.

        Parameter 'orig' is the Input instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            Input(QualPkgNamespaces qualns)

        Creates a new Input with the given QualPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'qualns' is the QualPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_Input(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(Input self) -> Input


        Creates and returns a deep copy of this Input object.

        Returns a (deep) copy of this Input object.

        """
        return _libsbml.Input_clone(self)

    __swig_destroy__ = _libsbml.delete_Input
    __del__ = lambda self: None

    def getId(self):
        """
        getId(Input self) -> string


        Returns the value of the 'id' attribute of this Input.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is now recommended to use the
        getIdAttribute() function instead.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns the id of this Input.

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.Input_getId(self)


    def getQualitativeSpecies(self):
        """
        getQualitativeSpecies(Input self) -> string


        Returns the value of the 'qualitativeSpecies' attribute of this Input.

        Returns the value of the 'qualitativeSpecies' attribute of this Input
        as a string.

        """
        return _libsbml.Input_getQualitativeSpecies(self)


    def getTransitionEffect(self):
        """
        getTransitionEffect(Input self) -> InputTransitionEffect_t


        Returns the value of the 'transitionEffect' attribute of this Input.

        Returns the value of the 'transitionEffect' attribute of this Input as
        a string.

        """
        return _libsbml.Input_getTransitionEffect(self)


    def getName(self):
        """
        getName(Input self) -> string


        Returns the value of the 'name' attribute of this Input object.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns the name of this SBML object, or the empty string if not set
        or unsettable.

        See also getIdAttribute(), isSetName(), setName(), unsetName().

        """
        return _libsbml.Input_getName(self)


    def getSign(self):
        """
        getSign(Input self) -> InputSign_t


        Returns the value of the 'sign' attribute of this Input.

        Returns the value of the 'sign' attribute of this Input as a string.

        """
        return _libsbml.Input_getSign(self)


    def getThresholdLevel(self):
        """
        getThresholdLevel(Input self) -> int


        Returns the value of the 'thresholdLevel' attribute of this Input.

        Returns the value of the 'thresholdLevel' attribute of this Input as a
        integer.

        """
        return _libsbml.Input_getThresholdLevel(self)


    def isSetId(self):
        """
        isSetId(Input self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        Input's 'id' attribute has been set.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns 'True' if the 'id' attribute of this SBML object is set,
        'False' otherwise.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is recommended that callers use
        isSetIdAttribute() instead.

        See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(),
        isSetIdAttribute().

        """
        return _libsbml.Input_isSetId(self)


    def isSetQualitativeSpecies(self):
        """
        isSetQualitativeSpecies(Input self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        Input's 'qualitativeSpecies' attribute has been set.

        Returns 'True' if this Input's 'qualitativeSpecies' attribute has been
        set, otherwise 'False' is returned.

        """
        return _libsbml.Input_isSetQualitativeSpecies(self)


    def isSetTransitionEffect(self):
        """
        isSetTransitionEffect(Input self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        Input's 'transitionEffect' attribute has been set.

        Returns 'True' if this Input's 'transitionEffect' attribute has been
        set, otherwise 'False' is returned.

        """
        return _libsbml.Input_isSetTransitionEffect(self)


    def isSetName(self):
        """
        isSetName(Input self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        Input's 'name' attribute has been set.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns 'True' if the 'name' attribute of this SBML object is set,
        'False' otherwise.

        See also getName(), setName(), unsetName().

        """
        return _libsbml.Input_isSetName(self)


    def isSetSign(self):
        """
        isSetSign(Input self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        Input's 'sign' attribute has been set.

        Returns 'True' if this Input's 'sign' attribute has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.Input_isSetSign(self)


    def isSetThresholdLevel(self):
        """
        isSetThresholdLevel(Input self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        Input's 'thresholdLevel' attribute has been set.

        Returns 'True' if this Input's 'thresholdLevel' attribute has been
        set, otherwise 'False' is returned.

        """
        return _libsbml.Input_isSetThresholdLevel(self)


    def setId(self, sid):
        """
        setId(Input self, string sid) -> int


        Sets the value of the 'id' attribute of this obInputject.

        The string 'sid' is copied.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Parameter 'sid' is the string to use as the identifier of this object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.Input_setId(self, sid)


    def setQualitativeSpecies(self, qualitativeSpecies):
        """
        setQualitativeSpecies(Input self, string qualitativeSpecies) -> int


        Sets the value of the 'qualitativeSpecies' attribute of this Input.

        Parameter 'qualitativeSpecies' is the value of the
        'qualitativeSpecies' attribute to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Input_setQualitativeSpecies(self, qualitativeSpecies)


    def setTransitionEffect(self, transitionEffect):
        """
        setTransitionEffect(Input self, InputTransitionEffect_t const transitionEffect) -> int


        Sets the value of the 'transitionEffect' attribute of this Input.

        Parameter 'transitionEffect' is the value of the 'transitionEffect'
        attribute to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Input_setTransitionEffect(self, transitionEffect)


    def setName(self, name):
        """
        setName(Input self, string name) -> int


        Sets the value of the 'name' attribute of this Input.

        The string in 'name' is copied.

        Parameter 'name' is the new name for the SBML object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Input_setName(self, name)


    def setSign(self, sign):
        """
        setSign(Input self, InputSign_t const sign) -> int


        Sets the value of the 'sign' attribute of this Input.

        Parameter 'sign' is the value of the 'sign' attribute to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Input_setSign(self, sign)


    def setThresholdLevel(self, thresholdLevel):
        """
        setThresholdLevel(Input self, int thresholdLevel) -> int


        Sets the value of the 'thresholdLevel' attribute of this Input.

        Parameter 'thresholdLevel' is int value of the 'thresholdLevel'
        attribute to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Input_setThresholdLevel(self, thresholdLevel)


    def unsetId(self):
        """
        unsetId(Input self) -> int


        Unsets the value of the 'id' attribute of this Input.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.Input_unsetId(self)


    def unsetQualitativeSpecies(self):
        """
        unsetQualitativeSpecies(Input self) -> int


        Unsets the value of the 'qualitativeSpecies' attribute of this Input.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Input_unsetQualitativeSpecies(self)


    def unsetTransitionEffect(self):
        """
        unsetTransitionEffect(Input self) -> int


        Unsets the value of the 'transitionEffect' attribute of this Input.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Input_unsetTransitionEffect(self)


    def unsetName(self):
        """
        unsetName(Input self) -> int


        Unsets the value of the 'name' attribute of this Input.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getName(), setName(), isSetName().

        """
        return _libsbml.Input_unsetName(self)


    def unsetSign(self):
        """
        unsetSign(Input self) -> int


        Unsets the value of the 'sign' attribute of this Input.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Input_unsetSign(self)


    def unsetThresholdLevel(self):
        """
        unsetThresholdLevel(Input self) -> int


        Unsets the value of the 'thresholdLevel' attribute of this Input.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Input_unsetThresholdLevel(self)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(Input self, string oldid, string newid)


        Replaces all uses of a given 'SIdRef' type attribute value with
        another value.

        In SBML, object identifiers are of a data type called SId. In SBML
        Level 3, an explicit data type called SIdRef was introduced for
        attribute values that refer to SId values; in previous Levels of SBML,
        this data type did not exist and attributes were simply described to
        as 'referring to an identifier', but the effective data type was the
        same as SIdRef in Level 3.  These and other methods of libSBML refer
        to the type SIdRef for all Levels of SBML, even if the corresponding
        SBML specification did not explicitly name the data type.

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas in MathML content, comparing the referenced
        identifiers to the value of 'oldid'.  If any matches are found, the
        matching values are replaced with 'newid'.  The method does not
        descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.Input_renameSIdRefs(self, oldid, newid)


    def getElementName(self):
        """
        getElementName(Input self) -> string


        Returns the XML name of this object.

        Returns the name of this element.

        """
        return _libsbml.Input_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(Input self) -> int


        Returns the libSBML type code of this object instance.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_QUAL_INPUT

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.Input_getTypeCode(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(Input self) -> bool


        Predicate returning 'True' if all the required attributes for this
        Input object have been set.

        Note: The required attributes for a Input object are:

        * 'qualitativeSpecies'

        * 'transitionEffect'

        Returns a boolean value indicating whether all the required attributes
        for this object have been defined.

        """
        return _libsbml.Input_hasRequiredAttributes(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(Input self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.Input_enablePackageInternal(self, pkgURI, pkgPrefix, flag)

Input_swigregister = _libsbml.Input_swigregister
Input_swigregister(Input)

class ListOfInputs(ListOf):
    """

    [SBML 'qual' package]

    A list of Input objects.

    The ListOfInputs is a container for the Inputs of a Transition.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    See also Input.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfInputs, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfInputs, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ListOfInputs self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ListOfInputs
        __init__(ListOfInputs self, unsigned int level, unsigned int version) -> ListOfInputs
        __init__(ListOfInputs self, unsigned int level) -> ListOfInputs
        __init__(ListOfInputs self) -> ListOfInputs
        __init__(ListOfInputs self, QualPkgNamespaces qualns) -> ListOfInputs


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfInputs(long level      =
        QualExtension.getDefaultLevel(), long version    =
        QualExtension.getDefaultVersion(), long pkgVersion =
        QualExtension.getDefaultPackageVersion())

        Creates a new ListOfInputs with the given level, version, and package
        version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        ListOfInputs.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this ListOfInputs.

        Parameter 'pkgVersion' is a long integer, the SBML Qual Version to
        assign to this ListOfInputs.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfInputs(QualPkgNamespaces qualns)

        Creates a new ListOfInputs with the given QualPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'qualns' is the QualPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_ListOfInputs(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ListOfInputs self) -> ListOfInputs


        Creates and returns a deep copy of this ListOfInputs object.

        Returns a (deep) copy of this ListOfInputs object.

        """
        return _libsbml.ListOfInputs_clone(self)


    def get(self, *args):
        """
        get(ListOfInputs self, unsigned int n) -> Input
        get(ListOfInputs self, unsigned int n) -> Input
        get(ListOfInputs self, string sid) -> Input
        get(ListOfInputs self, string sid) -> Input


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a Input from the ListOfInputs.

        Parameter 'n' is the index number of the Input to get.

        Returns the nth Input in this ListOfInputs. If the index 'n' is
        invalid, 'None' is returned.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a Input from the ListOfInputs based on its identifier.

        Parameter 'sid' is a string representing the identifier of the Input
        to get.

        Returns Input in this ListOfInputs with the given id or 'None' if no
        such Input exists.

        See also get()   *, size().

        """
        return _libsbml.ListOfInputs_get(self, *args)


    def getBySpecies(self, *args):
        """
        getBySpecies(ListOfInputs self, string sid) -> Input
        getBySpecies(ListOfInputs self, string sid) -> Input


        Get a Input from the ListOfInputs based on the qualitativeSpecies to
        which it refers.

        Parameter 'sid' is a string representing the qualitativeSpecies
        attribute of the Input to get.

        Returns the first Input in this ListOfInputs with the given
        qualitativeSpecies or 'None' if no such Input exists.

        See also get()   *, size().

        """
        return _libsbml.ListOfInputs_getBySpecies(self, *args)


    def remove(self, *args):
        """
        remove(ListOfInputs self, unsigned int n) -> Input
        remove(ListOfInputs self, string sid) -> Input


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth Input from this ListOfInputs and returns a pointer to
        it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the Input to remove.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes the Input from this ListOfInputs with the given identifier and
        returns a pointer to it.

        The caller owns the returned item and is responsible for deleting it.
        If none of the items in this list have the identifier 'sid', then
        'None' is returned.

        Parameter 'sid' is the identifier of the Input to remove.

        Returns the Input removed. As mentioned above, the caller owns the
        returned item.

        """
        return _libsbml.ListOfInputs_remove(self, *args)


    def getElementName(self):
        """
        getElementName(ListOfInputs self) -> string


        Returns the XML name of this object.

        Returns the name of this element.

        """
        return _libsbml.ListOfInputs_getElementName(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfInputs self) -> int


        Returns the libSBML type code for the SBML objects contained in this
        ListOf object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for objects contained in this list:
        SBML_QUAL_INPUT (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfInputs_getItemTypeCode(self)

    __swig_destroy__ = _libsbml.delete_ListOfInputs
    __del__ = lambda self: None
ListOfInputs_swigregister = _libsbml.ListOfInputs_swigregister
ListOfInputs_swigregister(ListOfInputs)

OUTPUT_TRANSITION_EFFECT_PRODUCTION = _libsbml.OUTPUT_TRANSITION_EFFECT_PRODUCTION
OUTPUT_TRANSITION_EFFECT_ASSIGNMENT_LEVEL = _libsbml.OUTPUT_TRANSITION_EFFECT_ASSIGNMENT_LEVEL
OUTPUT_TRANSITION_EFFECT_UNKNOWN = _libsbml.OUTPUT_TRANSITION_EFFECT_UNKNOWN
class Output(SBase):
    """

    [SBML 'qual' package]

    The output from a QualitativeSpecies.

    Each Output refers to a QualitativeSpecies that participates in (is
    affected by) the corresponding Transition. In Petri net models these
    are the output places of the transition.

    In a logical model, a QualitativeSpecies should be referenced in at
    most one ListOfOutputs, (that of the Transition defining the evolution
    of this species). When a Transition has several outputs, it is because
    the referenced species share the same regulators and the same logical
    rules.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Output, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Output, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(Output self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> Output
        __init__(Output self, unsigned int level, unsigned int version) -> Output
        __init__(Output self, unsigned int level) -> Output
        __init__(Output self) -> Output
        __init__(Output self, QualPkgNamespaces qualns) -> Output
        __init__(Output self, Output orig) -> Output


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            Output(long level      = QualExtension.getDefaultLevel(),
        long version    = QualExtension.getDefaultVersion(), long pkgVersion =
        QualExtension.getDefaultPackageVersion())

        Creates a new Output with the given level, version, and package
        version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        Output.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this Output.

        Parameter 'pkgVersion' is a long integer, the SBML Qual Version to
        assign to this Output.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            Output(Output orig)

        Copy constructor for Output.

        Parameter 'orig' is the Output instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            Output(QualPkgNamespaces qualns)

        Creates a new Output with the given QualPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'qualns' is the QualPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_Output(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(Output self) -> Output


        Creates and returns a deep copy of this Output object.

        Returns a (deep) copy of this Output object.

        """
        return _libsbml.Output_clone(self)

    __swig_destroy__ = _libsbml.delete_Output
    __del__ = lambda self: None

    def getId(self):
        """
        getId(Output self) -> string


        Returns the value of the 'id' attribute of this Output.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is now recommended to use the
        getIdAttribute() function instead.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns the id of this Output.

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.Output_getId(self)


    def getQualitativeSpecies(self):
        """
        getQualitativeSpecies(Output self) -> string


        Returns the value of the 'qualitativeSpecies' attribute of this
        Output.

        Returns the value of the 'qualitativeSpecies' attribute of this Output
        as a string.

        """
        return _libsbml.Output_getQualitativeSpecies(self)


    def getTransitionEffect(self):
        """
        getTransitionEffect(Output self) -> OutputTransitionEffect_t


        Returns the value of the 'transitionEffect' attribute of this Output.

        Returns the value of the 'transitionEffect' attribute of this Output
        as a string.

        """
        return _libsbml.Output_getTransitionEffect(self)


    def getName(self):
        """
        getName(Output self) -> string


        Returns the value of the 'name' attribute of this Output object.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns the name of this SBML object, or the empty string if not set
        or unsettable.

        See also getIdAttribute(), isSetName(), setName(), unsetName().

        """
        return _libsbml.Output_getName(self)


    def getOutputLevel(self):
        """
        getOutputLevel(Output self) -> int


        Returns the value of the 'outputLevel' attribute of this Output.

        Returns the value of the 'outputLevel' attribute of this Output as a
        integer.

        """
        return _libsbml.Output_getOutputLevel(self)


    def isSetId(self):
        """
        isSetId(Output self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        Output's 'id' attribute has been set.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns 'True' if the 'id' attribute of this SBML object is set,
        'False' otherwise.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is recommended that callers use
        isSetIdAttribute() instead.

        See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(),
        isSetIdAttribute().

        """
        return _libsbml.Output_isSetId(self)


    def isSetQualitativeSpecies(self):
        """
        isSetQualitativeSpecies(Output self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        Output's 'qualitativeSpecies' attribute has been set.

        Returns 'True' if this Output's 'qualitativeSpecies' attribute has
        been set, otherwise 'False' is returned.

        """
        return _libsbml.Output_isSetQualitativeSpecies(self)


    def isSetTransitionEffect(self):
        """
        isSetTransitionEffect(Output self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        Output's 'transitionEffect' attribute has been set.

        Returns 'True' if this Output's 'transitionEffect' attribute has been
        set, otherwise 'False' is returned.

        """
        return _libsbml.Output_isSetTransitionEffect(self)


    def isSetName(self):
        """
        isSetName(Output self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        Output's 'name' attribute has been set.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns 'True' if the 'name' attribute of this SBML object is set,
        'False' otherwise.

        See also getName(), setName(), unsetName().

        """
        return _libsbml.Output_isSetName(self)


    def isSetOutputLevel(self):
        """
        isSetOutputLevel(Output self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        Output's 'outputLevel' attribute has been set.

        Returns 'True' if this Output's 'outputLevel' attribute has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.Output_isSetOutputLevel(self)


    def setId(self, sid):
        """
        setId(Output self, string sid) -> int


        Sets the value of the 'id' attribute of this Output.

        The string 'sid' is copied.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Parameter 'sid' is the string to use as the identifier of this object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.Output_setId(self, sid)


    def setQualitativeSpecies(self, qualitativeSpecies):
        """
        setQualitativeSpecies(Output self, string qualitativeSpecies) -> int


        Sets the value of the 'qualitativeSpecies' attribute of this Output.

        Parameter 'qualitativeSpecies' is the value of the
        'qualitativeSpecies' attribute to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Output_setQualitativeSpecies(self, qualitativeSpecies)


    def setTransitionEffect(self, transitionEffect):
        """
        setTransitionEffect(Output self, OutputTransitionEffect_t const transitionEffect) -> int


        Sets the value of the 'transitionEffect' attribute of this Output.

        Parameter 'transitionEffect' is the value of the 'transitionEffect'
        attribute to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Output_setTransitionEffect(self, transitionEffect)


    def setName(self, name):
        """
        setName(Output self, string name) -> int


        Sets the value of the 'name' attribute of this Output.

        The string in 'name' is copied.

        Parameter 'name' is the new name for the SBML object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Output_setName(self, name)


    def setOutputLevel(self, outputLevel):
        """
        setOutputLevel(Output self, int outputLevel) -> int


        Sets the value of the 'outputLevel' attribute of this Output.

        Parameter 'outputLevel' is int value of the 'outputLevel' attribute to
        be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Output_setOutputLevel(self, outputLevel)


    def unsetId(self):
        """
        unsetId(Output self) -> int


        Unsets the value of the 'id' attribute of this Output.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.Output_unsetId(self)


    def unsetQualitativeSpecies(self):
        """
        unsetQualitativeSpecies(Output self) -> int


        Unsets the value of the 'qualitativeSpecies' attribute of this Output.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Output_unsetQualitativeSpecies(self)


    def unsetTransitionEffect(self):
        """
        unsetTransitionEffect(Output self) -> int


        Unsets the value of the 'transitionEffect' attribute of this Output.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Output_unsetTransitionEffect(self)


    def unsetName(self):
        """
        unsetName(Output self) -> int


        Unsets the value of the 'name' attribute of this Output.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getName(), setName(), isSetName().

        """
        return _libsbml.Output_unsetName(self)


    def unsetOutputLevel(self):
        """
        unsetOutputLevel(Output self) -> int


        Unsets the value of the 'outputLevel' attribute of this Output.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Output_unsetOutputLevel(self)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(Output self, string oldid, string newid)


        Replaces all uses of a given 'SIdRef' type attribute value with
        another value.

        In SBML, object identifiers are of a data type called SId. In SBML
        Level 3, an explicit data type called SIdRef was introduced for
        attribute values that refer to SId values; in previous Levels of SBML,
        this data type did not exist and attributes were simply described to
        as 'referring to an identifier', but the effective data type was the
        same as SIdRef in Level 3.  These and other methods of libSBML refer
        to the type SIdRef for all Levels of SBML, even if the corresponding
        SBML specification did not explicitly name the data type.

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas in MathML content, comparing the referenced
        identifiers to the value of 'oldid'.  If any matches are found, the
        matching values are replaced with 'newid'.  The method does not
        descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.Output_renameSIdRefs(self, oldid, newid)


    def getElementName(self):
        """
        getElementName(Output self) -> string


        Returns the XML name of this object.

        Returns the name of this element.

        """
        return _libsbml.Output_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(Output self) -> int


        Returns the libSBML type code of this object instance.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_QUAL_OUTPUT

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.Output_getTypeCode(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(Output self) -> bool


        Predicate returning 'True' if all the required attributes for this
        Output object have been set.

        Note: The required attributes for a Output object are:

        * 'qualitativeSpecies'

        * 'transitionEffect'

        Returns a boolean value indicating whether all the required attributes
        for this object have been defined.

        """
        return _libsbml.Output_hasRequiredAttributes(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(Output self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.Output_enablePackageInternal(self, pkgURI, pkgPrefix, flag)

Output_swigregister = _libsbml.Output_swigregister
Output_swigregister(Output)

class ListOfOutputs(ListOf):
    """

    [SBML 'qual' package]

    A list of Output objects.

    The ListOfOutputs is a container for the Output elements of a
    Transition.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    See also Output.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfOutputs, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfOutputs, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ListOfOutputs self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ListOfOutputs
        __init__(ListOfOutputs self, unsigned int level, unsigned int version) -> ListOfOutputs
        __init__(ListOfOutputs self, unsigned int level) -> ListOfOutputs
        __init__(ListOfOutputs self) -> ListOfOutputs
        __init__(ListOfOutputs self, QualPkgNamespaces qualns) -> ListOfOutputs


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfOutputs(long level      =
        QualExtension.getDefaultLevel(), long version    =
        QualExtension.getDefaultVersion(), long pkgVersion =
        QualExtension.getDefaultPackageVersion())

        Creates a new ListOfOutputs with the given level, version, and package
        version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        ListOfOutputs.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this ListOfOutputs.

        Parameter 'pkgVersion' is a long integer, the SBML Qual Version to
        assign to this ListOfOutputs.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfOutputs(QualPkgNamespaces qualns)

        Creates a new ListOfOutputs with the given QualPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'qualns' is the QualPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_ListOfOutputs(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ListOfOutputs self) -> ListOfOutputs


        Creates and returns a deep copy of this ListOfOutputs object.

        Returns a (deep) copy of this ListOfOutputs object.

        """
        return _libsbml.ListOfOutputs_clone(self)


    def get(self, *args):
        """
        get(ListOfOutputs self, unsigned int n) -> Output
        get(ListOfOutputs self, unsigned int n) -> Output
        get(ListOfOutputs self, string sid) -> Output
        get(ListOfOutputs self, string sid) -> Output


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a Output from the ListOfOutputs.

        Parameter 'n' is the index number of the Output to get.

        Returns the nth Output in this ListOfOutputs. If the index 'n' is
        invalid, 'None' is returned.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a Output from the ListOfOutputs based on its identifier.

        Parameter 'sid' is a string representing the identifier of the Output
        to get.

        Returns Output in this ListOfOutputs with the given id or 'None' if no
        such Output exists.

        See also get()   *, size().

        """
        return _libsbml.ListOfOutputs_get(self, *args)


    def getBySpecies(self, *args):
        """
        getBySpecies(ListOfOutputs self, string sid) -> Output
        getBySpecies(ListOfOutputs self, string sid) -> Output


        Get a Output from the ListOfOutputs based on the qualitativeSpecies to
        which it refers.

        Parameter 'sid' is a string representing the qualitativeSpecies
        attribute of the Output to get.

        Returns the first Output in this ListOfOutputs with the given
        qualitativeSpecies or 'None' if no such Output exists.

        See also get()   *, size().

        """
        return _libsbml.ListOfOutputs_getBySpecies(self, *args)


    def remove(self, *args):
        """
        remove(ListOfOutputs self, unsigned int n) -> Output
        remove(ListOfOutputs self, string sid) -> Output


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth Output from this ListOfOutputs and returns a pointer
        to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the Output to remove.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes the Output from this ListOfOutputs with the given identifier
        and returns a pointer to it.

        The caller owns the returned item and is responsible for deleting it.
        If none of the items in this list have the identifier 'sid', then
        'None' is returned.

        Parameter 'sid' is the identifier of the Output to remove.

        Returns the Output removed. As mentioned above, the caller owns the
        returned item.

        """
        return _libsbml.ListOfOutputs_remove(self, *args)


    def getElementName(self):
        """
        getElementName(ListOfOutputs self) -> string


        Returns the XML name of this object.

        Returns the name of this element.

        """
        return _libsbml.ListOfOutputs_getElementName(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfOutputs self) -> int


        Returns the libSBML type code for the SBML objects contained in this
        ListOf object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for objects contained in this list:
        SBML_QUAL_OUTPUT (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfOutputs_getItemTypeCode(self)

    __swig_destroy__ = _libsbml.delete_ListOfOutputs
    __del__ = lambda self: None
ListOfOutputs_swigregister = _libsbml.ListOfOutputs_swigregister
ListOfOutputs_swigregister(ListOfOutputs)

class QualitativeSpecies(SBase):
    """

    [SBML 'qual' package]

    Extension of Species.

    Similarly to the Species in SBML, the components of qualitative models
    refer to pools of entities that are considered indistinguishable and
    are each located in a specific Compartment. However, here components
    are characterised by their qualitative influences rather than by
    taking part in reactions. Therefore, we define the QualitativeSpecies
    element to represent such pools of entities.

    In a Petri net, qualitative species refer to the places of the model,
    while in a logical model, they refer to the variables of this model
    (i.e. nodes of the influence graph).

    A QualitativeSpecies describes a pool of indistinguishable entities in
    a Compartment. It is associated with a level (an integer representing
    e.g. an activity state, or a functional level of concentration, etc.)

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, QualitativeSpecies, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, QualitativeSpecies, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(QualitativeSpecies self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> QualitativeSpecies
        __init__(QualitativeSpecies self, unsigned int level, unsigned int version) -> QualitativeSpecies
        __init__(QualitativeSpecies self, unsigned int level) -> QualitativeSpecies
        __init__(QualitativeSpecies self) -> QualitativeSpecies
        __init__(QualitativeSpecies self, QualPkgNamespaces qualns) -> QualitativeSpecies
        __init__(QualitativeSpecies self, QualitativeSpecies orig) -> QualitativeSpecies


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            QualitativeSpecies(QualitativeSpecies orig)

        Copy constructor for QualitativeSpecies.

        Parameter 'orig' is the QualitativeSpecies instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            QualitativeSpecies(long level      =
        QualExtension.getDefaultLevel(), long version    =
        QualExtension.getDefaultVersion(), long pkgVersion =
        QualExtension.getDefaultPackageVersion())

        Creates a new QualitativeSpecies with the given level, version, and
        package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        QualitativeSpecies.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this QualitativeSpecies.

        Parameter 'pkgVersion' is a long integer, the SBML Qual Version to
        assign to this QualitativeSpecies.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            QualitativeSpecies(QualPkgNamespaces qualns)

        Creates a new QualitativeSpecies with the given QualPkgNamespaces
        object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'qualns' is the QualPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_QualitativeSpecies(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(QualitativeSpecies self) -> QualitativeSpecies


        Creates and returns a deep copy of this QualitativeSpecies object.

        Returns a (deep) copy of this QualitativeSpecies object.

        """
        return _libsbml.QualitativeSpecies_clone(self)

    __swig_destroy__ = _libsbml.delete_QualitativeSpecies
    __del__ = lambda self: None

    def getId(self):
        """
        getId(QualitativeSpecies self) -> string


        Returns the value of the 'id' attribute of this QualitativeSpecies.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is now recommended to use the
        getIdAttribute() function instead.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns the id of this QualitativeSpecies.

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.QualitativeSpecies_getId(self)


    def getCompartment(self):
        """
        getCompartment(QualitativeSpecies self) -> string


        Returns the value of the 'compartment' attribute of this
        QualitativeSpecies.

        Returns the value of the 'compartment' attribute of this
        QualitativeSpecies as a string.

        """
        return _libsbml.QualitativeSpecies_getCompartment(self)


    def getConstant(self):
        """
        getConstant(QualitativeSpecies self) -> bool


        Returns the value of the 'constant' attribute of this
        QualitativeSpecies.

        Returns the value of the 'constant' attribute of this
        QualitativeSpecies as a boolean.

        """
        return _libsbml.QualitativeSpecies_getConstant(self)


    def getName(self):
        """
        getName(QualitativeSpecies self) -> string


        Returns the value of the 'name' attribute of this QualitativeSpecies
        object.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns the name of this SBML object, or the empty string if not set
        or unsettable.

        See also getIdAttribute(), isSetName(), setName(), unsetName().

        """
        return _libsbml.QualitativeSpecies_getName(self)


    def getInitialLevel(self):
        """
        getInitialLevel(QualitativeSpecies self) -> int


        Returns the value of the 'initialLevel' attribute of this
        QualitativeSpecies.

        Returns the value of the 'initialLevel' attribute of this
        QualitativeSpecies as a integer.

        """
        return _libsbml.QualitativeSpecies_getInitialLevel(self)


    def getMaxLevel(self):
        """
        getMaxLevel(QualitativeSpecies self) -> int


        Returns the value of the 'maxLevel' attribute of this
        QualitativeSpecies.

        Returns the value of the 'maxLevel' attribute of this
        QualitativeSpecies as a integer.

        """
        return _libsbml.QualitativeSpecies_getMaxLevel(self)


    def isSetId(self):
        """
        isSetId(QualitativeSpecies self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        QualitativeSpecies's 'id' attribute has been set.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns 'True' if the 'id' attribute of this SBML object is set,
        'False' otherwise.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is recommended that callers use
        isSetIdAttribute() instead.

        See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(),
        isSetIdAttribute().

        """
        return _libsbml.QualitativeSpecies_isSetId(self)


    def isSetCompartment(self):
        """
        isSetCompartment(QualitativeSpecies self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        QualitativeSpecies's 'compartment' attribute has been set.

        Returns 'True' if this QualitativeSpecies's 'compartment' attribute
        has been set, otherwise 'False' is returned.

        """
        return _libsbml.QualitativeSpecies_isSetCompartment(self)


    def isSetConstant(self):
        """
        isSetConstant(QualitativeSpecies self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        QualitativeSpecies's 'constant' attribute has been set.

        Returns 'True' if this QualitativeSpecies's 'constant' attribute has
        been set, otherwise 'False' is returned.

        """
        return _libsbml.QualitativeSpecies_isSetConstant(self)


    def isSetName(self):
        """
        isSetName(QualitativeSpecies self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        QualitativeSpecies's 'name' attribute has been set.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns 'True' if the 'name' attribute of this SBML object is set,
        'False' otherwise.

        See also getName(), setName(), unsetName().

        """
        return _libsbml.QualitativeSpecies_isSetName(self)


    def isSetInitialLevel(self):
        """
        isSetInitialLevel(QualitativeSpecies self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        QualitativeSpecies's 'initialLevel' attribute has been set.

        Returns 'True' if this QualitativeSpecies's 'initialLevel' attribute
        has been set, otherwise 'False' is returned.

        """
        return _libsbml.QualitativeSpecies_isSetInitialLevel(self)


    def isSetMaxLevel(self):
        """
        isSetMaxLevel(QualitativeSpecies self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        QualitativeSpecies's 'maxLevel' attribute has been set.

        Returns 'True' if this QualitativeSpecies's 'maxLevel' attribute has
        been set, otherwise 'False' is returned.

        """
        return _libsbml.QualitativeSpecies_isSetMaxLevel(self)


    def setId(self, sid):
        """
        setId(QualitativeSpecies self, string sid) -> int


        Sets the value of the 'id' attribute of this QualitativeSpecies.

        The string 'sid' is copied.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Parameter 'sid' is the string to use as the identifier of this object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.QualitativeSpecies_setId(self, sid)


    def setCompartment(self, compartment):
        """
        setCompartment(QualitativeSpecies self, string compartment) -> int


        Sets the value of the 'compartment' attribute of this
        QualitativeSpecies.

        Parameter 'compartment' is the value of the 'compartment' attribute to
        be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.QualitativeSpecies_setCompartment(self, compartment)


    def setConstant(self, constant):
        """
        setConstant(QualitativeSpecies self, bool constant) -> int


        Sets the value of the 'constant' attribute of this QualitativeSpecies.

        Parameter 'constant' is bool value of the 'constant' attribute to be
        set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.QualitativeSpecies_setConstant(self, constant)


    def setName(self, name):
        """
        setName(QualitativeSpecies self, string name) -> int


        Sets the value of the 'name' attribute of this QualitativeSpecies.

        The string in 'name' is copied.

        Parameter 'name' is the new name for the SBML object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.QualitativeSpecies_setName(self, name)


    def setInitialLevel(self, initialLevel):
        """
        setInitialLevel(QualitativeSpecies self, int initialLevel) -> int


        Sets the value of the 'initialLevel' attribute of this
        QualitativeSpecies.

        Parameter 'initialLevel' is int value of the 'initialLevel' attribute
        to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.QualitativeSpecies_setInitialLevel(self, initialLevel)


    def setMaxLevel(self, maxLevel):
        """
        setMaxLevel(QualitativeSpecies self, int maxLevel) -> int


        Sets the value of the 'maxLevel' attribute of this QualitativeSpecies.

        Parameter 'maxLevel' is int value of the 'maxLevel' attribute to be
        set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.QualitativeSpecies_setMaxLevel(self, maxLevel)


    def unsetId(self):
        """
        unsetId(QualitativeSpecies self) -> int


        Unsets the value of the 'id' attribute of this QualitativeSpecies.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.QualitativeSpecies_unsetId(self)


    def unsetCompartment(self):
        """
        unsetCompartment(QualitativeSpecies self) -> int


        Unsets the value of the 'compartment' attribute of this
        QualitativeSpecies.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.QualitativeSpecies_unsetCompartment(self)


    def unsetConstant(self):
        """
        unsetConstant(QualitativeSpecies self) -> int


        Unsets the value of the 'constant' attribute of this
        QualitativeSpecies.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.QualitativeSpecies_unsetConstant(self)


    def unsetName(self):
        """
        unsetName(QualitativeSpecies self) -> int


        Unsets the value of the 'name' attribute of this QualitativeSpecies.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getName(), setName(), isSetName().

        """
        return _libsbml.QualitativeSpecies_unsetName(self)


    def unsetInitialLevel(self):
        """
        unsetInitialLevel(QualitativeSpecies self) -> int


        Unsets the value of the 'initialLevel' attribute of this
        QualitativeSpecies.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.QualitativeSpecies_unsetInitialLevel(self)


    def unsetMaxLevel(self):
        """
        unsetMaxLevel(QualitativeSpecies self) -> int


        Unsets the value of the 'maxLevel' attribute of this
        QualitativeSpecies.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.QualitativeSpecies_unsetMaxLevel(self)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(QualitativeSpecies self, string oldid, string newid)


        Replaces all uses of a given 'SIdRef' type attribute value with
        another value.

        In SBML, object identifiers are of a data type called SId. In SBML
        Level 3, an explicit data type called SIdRef was introduced for
        attribute values that refer to SId values; in previous Levels of SBML,
        this data type did not exist and attributes were simply described to
        as 'referring to an identifier', but the effective data type was the
        same as SIdRef in Level 3.  These and other methods of libSBML refer
        to the type SIdRef for all Levels of SBML, even if the corresponding
        SBML specification did not explicitly name the data type.

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas in MathML content, comparing the referenced
        identifiers to the value of 'oldid'.  If any matches are found, the
        matching values are replaced with 'newid'.  The method does not
        descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.QualitativeSpecies_renameSIdRefs(self, oldid, newid)


    def getElementName(self):
        """
        getElementName(QualitativeSpecies self) -> string


        Returns the XML name of this object.

        Returns the name of this element.

        """
        return _libsbml.QualitativeSpecies_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(QualitativeSpecies self) -> int


        Returns the libSBML type code of this object instance.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object:
        SBML_QUAL_QUALITATIVE_SPECIES

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.QualitativeSpecies_getTypeCode(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(QualitativeSpecies self) -> bool


        Predicate returning 'True' if all the required attributes for this
        QualitativeSpecies object have been set.

        Note: The required attributes for a QualitativeSpecies object are:

        * 'id'

        * 'compartment'

        * 'constant'

        Returns a boolean value indicating whether all the required attributes
        for this object have been defined.

        """
        return _libsbml.QualitativeSpecies_hasRequiredAttributes(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(QualitativeSpecies self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.QualitativeSpecies_enablePackageInternal(self, pkgURI, pkgPrefix, flag)

QualitativeSpecies_swigregister = _libsbml.QualitativeSpecies_swigregister
QualitativeSpecies_swigregister(QualitativeSpecies)

class ListOfQualitativeSpecies(ListOf):
    """

    [SBML 'qual' package]

    A list of QualitativeSpecies objects.

    The ListOfQualitativeSpecies is a container for the QualitativeSpecies
    elements of a Model.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    See also QualitativeSpecies.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfQualitativeSpecies, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfQualitativeSpecies, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ListOfQualitativeSpecies self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ListOfQualitativeSpecies
        __init__(ListOfQualitativeSpecies self, unsigned int level, unsigned int version) -> ListOfQualitativeSpecies
        __init__(ListOfQualitativeSpecies self, unsigned int level) -> ListOfQualitativeSpecies
        __init__(ListOfQualitativeSpecies self) -> ListOfQualitativeSpecies
        __init__(ListOfQualitativeSpecies self, QualPkgNamespaces qualns) -> ListOfQualitativeSpecies


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfQualitativeSpecies(long level      =
        QualExtension.getDefaultLevel(), long version    =
        QualExtension.getDefaultVersion(), long pkgVersion =
        QualExtension.getDefaultPackageVersion())

        Creates a new ListOfQualitativeSpecies with the given level, version,
        and package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        ListOfQualitativeSpecies.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this ListOfQualitativeSpecies.

        Parameter 'pkgVersion' is a long integer, the SBML Qual Version to
        assign to this ListOfQualitativeSpecies.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfQualitativeSpecies(QualPkgNamespaces qualns)

        Creates a new ListOfQualitativeSpecies with the given
        QualPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'qualns' is the QualPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_ListOfQualitativeSpecies(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ListOfQualitativeSpecies self) -> ListOfQualitativeSpecies


        Creates and returns a deep copy of this ListOfQualitativeSpecies
        object.

        Returns a (deep) copy of this ListOfQualitativeSpecies object.

        """
        return _libsbml.ListOfQualitativeSpecies_clone(self)


    def get(self, *args):
        """
        get(ListOfQualitativeSpecies self, unsigned int n) -> QualitativeSpecies
        get(ListOfQualitativeSpecies self, unsigned int n) -> QualitativeSpecies
        get(ListOfQualitativeSpecies self, string sid) -> QualitativeSpecies
        get(ListOfQualitativeSpecies self, string sid) -> QualitativeSpecies


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a QualitativeSpecies from the ListOfQualitativeSpecies.

        Parameter 'n' is the index number of the QualitativeSpecies to get.

        Returns the nth QualitativeSpecies in this ListOfQualitativeSpecies.
        If the index 'n' is invalid, 'None' is returned.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a QualitativeSpecies from the ListOfQualitativeSpecies based on
        its identifier.

        Parameter 'sid' is a string representing the identifier of the
        QualitativeSpecies to get.

        Returns QualitativeSpecies in this ListOfQualitativeSpecies with the
        given id or 'None' if no such QualitativeSpecies exists.

        See also get()   *, size().

        """
        return _libsbml.ListOfQualitativeSpecies_get(self, *args)


    def remove(self, *args):
        """
        remove(ListOfQualitativeSpecies self, unsigned int n) -> QualitativeSpecies
        remove(ListOfQualitativeSpecies self, string sid) -> QualitativeSpecies


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth QualitativeSpecies from this ListOfQualitativeSpecies
        and returns a pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the QualitativeSpecies to remove.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes the QualitativeSpecies from this ListOfQualitativeSpecies with
        the given identifier and returns a pointer to it.

        The caller owns the returned item and is responsible for deleting it.
        If none of the items in this list have the identifier 'sid', then
        'None' is returned.

        Parameter 'sid' is the identifier of the QualitativeSpecies to remove.

        Returns the QualitativeSpecies removed. As mentioned above, the caller
        owns the returned item.

        """
        return _libsbml.ListOfQualitativeSpecies_remove(self, *args)


    def getElementName(self):
        """
        getElementName(ListOfQualitativeSpecies self) -> string


        Returns the XML name of this object.

        Returns the name of this element.

        """
        return _libsbml.ListOfQualitativeSpecies_getElementName(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfQualitativeSpecies self) -> int


        Returns the libSBML type code for the SBML objects contained in this
        ListOf object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for objects contained in this list:
        SBML_QUAL_QUALITATIVE_SPECIES (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfQualitativeSpecies_getItemTypeCode(self)

    __swig_destroy__ = _libsbml.delete_ListOfQualitativeSpecies
    __del__ = lambda self: None
ListOfQualitativeSpecies_swigregister = _libsbml.ListOfQualitativeSpecies_swigregister
ListOfQualitativeSpecies_swigregister(ListOfQualitativeSpecies)

class Transition(SBase):
    """

    [SBML 'qual' package]

    A transition of a QualitativeSpecies.

    A Transition element contains at most one ListOfInputs and one
    ListOfOutputs and exactly one ListOfFunctionTerms.

    A Transition defines the changes in level associated with the
    QualitativeSpecies that occur when a Transition is enabled.

    In logical models, a Transition is used to specify the logical rule
    associated with a QualitativeSpecies (that appears as an Output of
    this Transition). For example, the rule 'if A > 1 : B = 2' would be
    encapsulated as a Transition with QualitativeSpecies 'A' as an Input
    and 'B' as an Output; the 'if A > 1' rule being encode by the math
    element of a FunctionTerm with the resultLevel attribute having a
    value '2'.

    In Petri net models, a Transition is interpreted, using the common
    Petri net semantics, as events that might occur within the system
    causing tokens to be moved.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Transition, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Transition, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(Transition self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> Transition
        __init__(Transition self, unsigned int level, unsigned int version) -> Transition
        __init__(Transition self, unsigned int level) -> Transition
        __init__(Transition self) -> Transition
        __init__(Transition self, QualPkgNamespaces qualns) -> Transition
        __init__(Transition self, Transition orig) -> Transition


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            Transition(Transition orig)

        Copy constructor for Transition.

        Parameter 'orig' is the Transition instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            Transition(long level      = QualExtension.getDefaultLevel(),
        long version    = QualExtension.getDefaultVersion(), long pkgVersion =
        QualExtension.getDefaultPackageVersion())

        Creates a new Transition with the given level, version, and package
        version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        Transition.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this Transition.

        Parameter 'pkgVersion' is a long integer, the SBML Qual Version to
        assign to this Transition.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            Transition(QualPkgNamespaces qualns)

        Creates a new Transition with the given QualPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'qualns' is the QualPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_Transition(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(Transition self) -> Transition


        Creates and returns a deep copy of this Transition object.

        Returns a (deep) copy of this Transition object.

        """
        return _libsbml.Transition_clone(self)

    __swig_destroy__ = _libsbml.delete_Transition
    __del__ = lambda self: None

    def getElementBySId(self, id):
        """
        getElementBySId(Transition self, string id) -> SBase


        Returns the first child element found that has the given 'id'  in the
        model-wide SId namespace, or 'None' if no such object is found.

        Parameter 'id' is string representing the id of the object to find.

        Returns a pointer to the SBase element with the given 'id'.

        """
        return _libsbml.Transition_getElementBySId(self, id)


    def getElementByMetaId(self, metaid):
        """
        getElementByMetaId(Transition self, string metaid) -> SBase


        Returns the first child element it can find with the given 'metaid',
        or itself if it has the given 'metaid', or 'None' if no such object
        is found.

        Parameter 'metaid' is string representing the metaid of the object to
        find.

        Returns a pointer to the SBase element with the given 'metaid'.

        """
        return _libsbml.Transition_getElementByMetaId(self, metaid)


    def getId(self):
        """
        getId(Transition self) -> string


        Returns the value of the 'id' attribute of this Transition.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is now recommended to use the
        getIdAttribute() function instead.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns the id of this Transition.

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.Transition_getId(self)


    def getName(self):
        """
        getName(Transition self) -> string


        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns the name of this SBML object, or the empty string if not set
        or unsettable.

        See also getIdAttribute(), isSetName(), setName(), unsetName().

        """
        return _libsbml.Transition_getName(self)


    def isSetId(self):
        """
        isSetId(Transition self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        Transition's 'id' attribute has been set.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns 'True' if the 'id' attribute of this SBML object is set,
        'False' otherwise.

        Note: Because of the inconsistent behavior of this function with
        respect to assignments and rules, it is recommended that callers use
        isSetIdAttribute() instead.

        See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(),
        isSetIdAttribute().

        """
        return _libsbml.Transition_isSetId(self)


    def isSetName(self):
        """
        isSetName(Transition self) -> bool


        Predicate returning 'True' or 'False' depending on whether this
        Transition's 'name' attribute has been set.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns 'True' if the 'name' attribute of this SBML object is set,
        'False' otherwise.

        See also getName(), setName(), unsetName().

        """
        return _libsbml.Transition_isSetName(self)


    def setId(self, sid):
        """
        setId(Transition self, string sid) -> int


        Sets the value of the 'id' attribute of this Transition.

        The string 'sid' is copied.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Parameter 'sid' is the string to use as the identifier of this object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        * LIBSBML_UNEXPECTED_ATTRIBUTE

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.Transition_setId(self, sid)


    def setName(self, name):
        """
        setName(Transition self, string name) -> int


        Sets the value of the 'name' attribute of this Transition.

        The string in 'name' is copied.

        Parameter 'name' is the new name for the SBML object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Transition_setName(self, name)


    def unsetId(self):
        """
        unsetId(Transition self) -> int


        Unsets the value of the 'id' attribute of this Transition.

        The identifier given by an object's 'id' attribute value is used to
        identify the object within the SBML model definition. Other objects
        can refer to the component using this identifier.  The data type of
        'id' is always SId or a type derived from that, such as UnitSId,
        depending on the object in  question.  All data types are defined as
        follows:

          letter ::= 'a'..'z','A'..'Z'
          digit  ::= '0'..'9'
          idChar ::= letter | digit | '_'
          SId    ::= ( letter | '_' ) idChar*

        The characters ( and ) are used for grouping, the character * 'zero or
        more times', and the character | indicates logical 'or'.  The equality
        of SBML identifiers is determined by an exact character sequence
        match; i.e., comparisons must be performed in a case-sensitive manner.
        This applies to all uses of SId, SIdRef, and derived types.

        Users need to be aware of some important API issues that are the
        result of the history of SBML and libSBML.  Prior to SBML Level 3
        Version 2, SBML defined 'id' and 'name' attributes on only a subset of
        SBML objects.  To simplify the work of programmers, libSBML's API
        provided get, set, check, and unset on the SBase object class itself
        instead of on individual subobject classes. This made the get/set/etc.
        methods uniformly available on all objects in the libSBML API.
        LibSBML simply returned empty strings or otherwise did not act when
        the methods were applied to SBML objects that were not defined by the
        SBML specification to have 'id' or 'name' attributes.  Additional
        complications arose with the rule and assignment objects:
        InitialAssignment, EventAssignment, AssignmentRule, and RateRule.  In
        early versions of SBML, the rule object hierarchy was different, and
        in addition, then as now, they possess different attributes:
        'variable' (for the rules and event assignments), 'symbol' (for
        initial assignments), or neither (for algebraic rules).  Prior to SBML
        Level 3 Version 2, getId() would always return an empty string, and
        isSetId() would always return 'False' for objects of these classes.

        With the addition of 'id' and 'name' attributes on SBase in Level 3
        Version 2, it became necessary to introduce a new way to interact with
        the attributes more consistently in libSBML to avoid breaking backward
        compatibility in the behavior of the original 'id' methods.  For this
        reason, libSBML provides four functions (getIdAttribute(),
        setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that
        always act on the actual 'id' attribute inherited from SBase,
        regardless of the object's type.  These new methods should be used
        instead of the older getId()/setId()/etc. methods unless the old
        behavior is somehow necessary.  Regardless of the Level and Version of
        the SBML, these functions allow client applications to use more
        generalized code in some situations (for instance, when manipulating
        objects that are all known to have identifiers).  If the object in
        question does not posess an 'id' attribute according to the SBML
        specification for the Level and Version in use, libSBML will not allow
        the identifier to be set, nor will it read or write 'id' attributes
        for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(),
        unsetIdAttribute().

        """
        return _libsbml.Transition_unsetId(self)


    def unsetName(self):
        """
        unsetName(Transition self) -> int


        Unsets the value of the 'name' attribute of this Transition.

        In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved
        to SBase directly, instead of being defined individually for many (but
        not all) objects.  LibSBML has for a long time provided functions
        defined on SBase itself to get, set, and unset those attributes, which
        would fail or otherwise return empty strings if executed on any object
        for which those attributes were not defined.  Now that all SBase
        objects  define those attributes, those functions now succeed for any
        object with  the appropriate level and version.

        The 'name' attribute is optional and is not intended to be used for
        cross-referencing purposes within a model.  Its purpose instead is to
        provide a human-readable label for the component.  The data type of
        'name' is the type string defined in XML Schema.  SBML imposes no
        restrictions as to the content of 'name' attributes beyond those
        restrictions defined by the string type in XML Schema.

        The recommended practice for handling 'name' is as follows.  If a
        software tool has the capability for displaying the content of 'name'
        attributes, it should display this content to the user as a
        component's label instead of the component's 'id'.  If the user
        interface does not have this capability (e.g., because it cannot
        display or use special characters in symbol names), or if the 'name'
        attribute is missing on a given component, then the user interface
        should display the value of the 'id' attribute instead.  (Script
        language interpreters are especially likely to display 'id' instead of
        'name'.)

        As a consequence of the above, authors of systems that automatically
        generate the values of 'id' attributes should be aware some systems
        may display the 'id''s to the user.  Authors therefore may wish to
        take some care to have their software create 'id' values that are: (a)
        reasonably easy for humans to type and read; and (b) likely to be
        meaningful, for example by making the 'id' attribute be an abbreviated
        form of the name attribute value.

        An additional point worth mentioning is although there are
        restrictions on the uniqueness of 'id' values, there are no
        restrictions on the uniqueness of 'name' values in a model.  This
        allows software applications leeway in assigning component
        identifiers.

        Regardless of the level and version of the SBML, these functions allow
        client applications to use more generalized code in some situations
        (for instance, when manipulating objects that are all known to have
        names).  If the object in question does not posess a 'name' attribute
        according to the SBML specification for the Level and Version in use,
        libSBML will not allow the name to be set, nor will it read or  write
        'name' attributes for those objects.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        See also getName(), setName(), isSetName().

        """
        return _libsbml.Transition_unsetName(self)


    def getListOfInputs(self, *args):
        """
        getListOfInputs(Transition self) -> ListOfInputs
        getListOfInputs(Transition self) -> ListOfInputs


        Returns the ListOfInputs in this Transition object.

        Returns the ListOfInputs child of this Transition.

        """
        return _libsbml.Transition_getListOfInputs(self, *args)


    def getInput(self, *args):
        """
        getInput(Transition self, unsigned int n) -> Input
        getInput(Transition self, unsigned int n) -> Input
        getInput(Transition self, string sid) -> Input
        getInput(Transition self, string sid) -> Input


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getInput(long n)

        Get a Input from the ListOfInputs.

        Parameter 'n' is the index number of the Input to get.

        Returns the nth Input in the ListOfInputs within this Transition. If
        the index 'n' is invalid, 'None' is returned.

        See also getNumInputs().

        ______________________________________________________________________
        Method variant with the following signature:

            getInput(string sid)

        Get a Input from the ListOfInputs based on its identifier.

        Parameter 'sid' is a string representing the identifier of the Input
        to get.

        Returns the Input in the ListOfInputs with the given id or 'None' if
        no such Input exists.

        See also getInput().

        See also getNumInputs().

        """
        return _libsbml.Transition_getInput(self, *args)


    def getInputBySpecies(self, *args):
        """
        getInputBySpecies(Transition self, string sid) -> Input
        getInputBySpecies(Transition self, string sid) -> Input


        Get a Input from the ListOfInputs based on its qualitativeSpecies
        attribute.

        Parameter 'sid' is a string representing the qualitativeSpecies of the
        Input to get.

        Returns the first Input in the ListOfInputs with the given
        qualitativeSpecies or 'None' if no such Input exists.

        See also getInput().

        See also getNumInputs().

        """
        return _libsbml.Transition_getInputBySpecies(self, *args)


    def addInput(self, i):
        """
        addInput(Transition self, Input i) -> int


        Adds a copy the given Input to this Transition.

        Parameter 'i' is the Input object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Transition_addInput(self, i)


    def getNumInputs(self):
        """
        getNumInputs(Transition self) -> unsigned int


        Get the number of Input objects in this Transition.

        Returns the number of Input objects in this Transition.

        """
        return _libsbml.Transition_getNumInputs(self)


    def createInput(self):
        """
        createInput(Transition self) -> Input


        Creates a new Input object, adds it to this Transition's ListOfInputs
        and returns the Input object created.

        Returns a new Input object instance.

        See also addInput().

        """
        return _libsbml.Transition_createInput(self)


    def removeInput(self, *args):
        """
        removeInput(Transition self, unsigned int n) -> Input
        removeInput(Transition self, string sid) -> Input


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeInput(long n)

        Removes the nth Input from the ListOfInputs within this Transition.
        and returns a pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the Input to remove.

        See also getNumInputs().

        ______________________________________________________________________
        Method variant with the following signature:

            removeInput(string sid)

        Removes the Input with the given identifier from the ListOfInputs
        within this Transition and returns a pointer to it.

        The caller owns the returned item and is responsible for deleting it.
        If none of the items in this list have the identifier 'sid', then
        'None' is returned.

        Parameter 'sid' is the identifier of the Input to remove.

        Returns the Input removed. As mentioned above, the caller owns the
        returned item.

        """
        return _libsbml.Transition_removeInput(self, *args)


    def getListOfOutputs(self, *args):
        """
        getListOfOutputs(Transition self) -> ListOfOutputs
        getListOfOutputs(Transition self) -> ListOfOutputs


        Returns the ListOfOutputs in this Transition object.

        Returns the ListOfOutputs child of this Transition.

        """
        return _libsbml.Transition_getListOfOutputs(self, *args)


    def getOutput(self, *args):
        """
        getOutput(Transition self, unsigned int n) -> Output
        getOutput(Transition self, unsigned int n) -> Output
        getOutput(Transition self, string sid) -> Output
        getOutput(Transition self, string sid) -> Output


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getOutput(long n)

        Get a Output from the ListOfOutputs.

        Parameter 'n' is the index number of the Output to get.

        Returns the nth Output in the ListOfOutputs within this Transition. If
        the index 'n' is invalid, 'None' is returned.

        See also getNumOutputs().

        ______________________________________________________________________
        Method variant with the following signature:

            getOutput(string sid)

        Get a Output from the ListOfOutputs based on its identifier.

        Parameter 'sid' is a string representing the identifier of the Output
        to get.

        Returns the Output in the ListOfOutputs with the given id or 'None' if
        no such Output exists.

        See also getOutput().

        See also getNumOutputs().

        """
        return _libsbml.Transition_getOutput(self, *args)


    def getOutputBySpecies(self, *args):
        """
        getOutputBySpecies(Transition self, string sid) -> Output
        getOutputBySpecies(Transition self, string sid) -> Output


        Get a Output from the ListOfOutputs based on its qualitativeSpecies
        attribute.

        Parameter 'sid' is a string representing the qualitativeSpecies of the
        Output to get.

        Returns the first Output in the ListOfOutputs with the given
        qualitativeSpecies or 'None' if no such Output exists.

        See also getOutput().

        See also getNumOutputs().

        """
        return _libsbml.Transition_getOutputBySpecies(self, *args)


    def addOutput(self, o):
        """
        addOutput(Transition self, Output o) -> int


        Adds a copy the given Output to this Transition.

        Parameter 'o' is the Output object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Transition_addOutput(self, o)


    def getNumOutputs(self):
        """
        getNumOutputs(Transition self) -> unsigned int


        Get the number of Output objects in this Transition.

        Returns the number of Output objects in this Transition.

        """
        return _libsbml.Transition_getNumOutputs(self)


    def createOutput(self):
        """
        createOutput(Transition self) -> Output


        Creates a new Output object, adds it to this Transition's
        ListOfOutputs and returns the Output object created.

        Returns a new Output object instance.

        See also addOutput().

        """
        return _libsbml.Transition_createOutput(self)


    def removeOutput(self, *args):
        """
        removeOutput(Transition self, unsigned int n) -> Output
        removeOutput(Transition self, string sid) -> Output


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeOutput(long n)

        Removes the nth Output from the ListOfOutputs within this Transition.
        and returns a pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the Output to remove.

        See also getNumOutputs().

        ______________________________________________________________________
        Method variant with the following signature:

            removeOutput(string sid)

        Removes the Output with the given identifier from the ListOfOutputs
        within this Transition and returns a pointer to it.

        The caller owns the returned item and is responsible for deleting it.
        If none of the items in this list have the identifier 'sid', then
        'None' is returned.

        Parameter 'sid' is the identifier of the Output to remove.

        Returns the Output removed. As mentioned above, the caller owns the
        returned item.

        """
        return _libsbml.Transition_removeOutput(self, *args)


    def getListOfFunctionTerms(self, *args):
        """
        getListOfFunctionTerms(Transition self) -> ListOfFunctionTerms
        getListOfFunctionTerms(Transition self) -> ListOfFunctionTerms


        Returns the ListOfFunctionTerms in this Transition object.

        Returns the ListOfFunctionTerms child of this Transition.

        """
        return _libsbml.Transition_getListOfFunctionTerms(self, *args)


    def getFunctionTerm(self, *args):
        """
        getFunctionTerm(Transition self, unsigned int n) -> FunctionTerm
        getFunctionTerm(Transition self, unsigned int n) -> FunctionTerm
        getFunctionTerm(Transition self, string sid) -> FunctionTerm
        getFunctionTerm(Transition self, string sid) -> FunctionTerm


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getFunctionTerm(long n)

        Get a FunctionTerm from the ListOfFunctionTerms.

        Parameter 'n' is the index number of the FunctionTerm to get.

        Returns the nth FunctionTerm in the ListOfFunctionTerms within this
        Transition. If the index 'n' is invalid, 'None' is returned.

        See also getNumFunctionTerms().

        ______________________________________________________________________
        Method variant with the following signature:

            getFunctionTerm(string sid)

        Get a FunctionTerm from the ListOfFunctionTerms based on its
        identifier.

        Parameter 'sid' is a string representing the identifier of the
        FunctionTerm to get.

        Returns the FunctionTerm in the ListOfFunctionTerms with the given id
        or 'None' if no such FunctionTerm exists.

        See also getFunctionTerm().

        See also getNumFunctionTerms().

        """
        return _libsbml.Transition_getFunctionTerm(self, *args)


    def addFunctionTerm(self, ft):
        """
        addFunctionTerm(Transition self, FunctionTerm ft) -> int


        Adds a copy the given FunctionTerm to this Transition.

        Parameter 'ft' is the FunctionTerm object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Transition_addFunctionTerm(self, ft)


    def getNumFunctionTerms(self):
        """
        getNumFunctionTerms(Transition self) -> unsigned int


        Get the number of FunctionTerm objects in this Transition.

        Returns the number of FunctionTerm objects in this Transition.

        """
        return _libsbml.Transition_getNumFunctionTerms(self)


    def createFunctionTerm(self):
        """
        createFunctionTerm(Transition self) -> FunctionTerm


        Creates a new FunctionTerm object, adds it to this Transition's
        ListOfFunctionTerms and returns the FunctionTerm object created.

        Returns a new FunctionTerm object instance.

        See also addFunctionTerm().

        """
        return _libsbml.Transition_createFunctionTerm(self)


    def removeFunctionTerm(self, *args):
        """
        removeFunctionTerm(Transition self, unsigned int n) -> FunctionTerm
        removeFunctionTerm(Transition self, string sid) -> FunctionTerm


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeFunctionTerm(long n)

        Removes the nth FunctionTerm from the ListOfFunctionTerms within this
        Transition. and returns a pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the FunctionTerm to remove.

        See also getNumFunctionTerms().

        ______________________________________________________________________
        Method variant with the following signature:

            removeFunctionTerm(string sid)

        Removes the FunctionTerm with the given identifier from the
        ListOfFunctionTerms within this Transition and returns a pointer to
        it.

        The caller owns the returned item and is responsible for deleting it.
        If none of the items in this list have the identifier 'sid', then
        'None' is returned.

        Parameter 'sid' is the identifier of the FunctionTerm to remove.

        Returns the FunctionTerm removed. As mentioned above, the caller owns
        the returned item.

        """
        return _libsbml.Transition_removeFunctionTerm(self, *args)


    def createDefaultTerm(self):
        """
        createDefaultTerm(Transition self) -> DefaultTerm


        Creates a new DefaultTerm object, adds it to this Transition's
        ListOfFunctionTerms and returns the DefaultTerm object created.

        Returns a new DefaultTerm object instance.

        See also setDefaultTerm().

        """
        return _libsbml.Transition_createDefaultTerm(self)


    def setDefaultTerm(self, dt):
        """
        setDefaultTerm(Transition self, DefaultTerm dt) -> int


        Sets the given DefaultTerm to this Transition.

        Parameter 'dt' is the DefaultTerm object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Transition_setDefaultTerm(self, dt)


    def isSetDefaultTerm(self):
        """
        isSetDefaultTerm(Transition self) -> bool


        Predicate returning 'True' if the defaultTerm for this Transition
        object has been set.

        Returns a boolean value indicating whether the defaultTerm child for
        this object has been defined.

        """
        return _libsbml.Transition_isSetDefaultTerm(self)


    def getDefaultTerm(self, *args):
        """
        getDefaultTerm(Transition self) -> DefaultTerm
        getDefaultTerm(Transition self) -> DefaultTerm


        Get the DefaultTerm from the ListOfFunctionTerms.

        Returns the DefaultTerm in the ListOfFunctionTerms within this
        Transition, or 'None' if no such value is set.

        """
        return _libsbml.Transition_getDefaultTerm(self, *args)


    def getElementName(self):
        """
        getElementName(Transition self) -> string


        Returns the XML name of this object.

        Returns the name of this element.

        """
        return _libsbml.Transition_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(Transition self) -> int


        Returns the libSBML type code of this object instance.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_QUAL_TRANSITION.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.Transition_getTypeCode(self)


    def hasRequiredElements(self):
        """
        hasRequiredElements(Transition self) -> bool


        Predicate returning 'True' if all the required attributes for this
        Transition object have been set.

        Note: The required elements for a Transition object are:

        * a 'defaultTerm' child of the child ListOfFunctionTerms.

        Returns a boolean value indicating whether all the required elements
        for this object have been defined.

        """
        return _libsbml.Transition_hasRequiredElements(self)


    def connectToChild(self):
        """
        connectToChild(Transition self)


        Internal implementation method.

        """
        return _libsbml.Transition_connectToChild(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(Transition self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.Transition_enablePackageInternal(self, pkgURI, pkgPrefix, flag)


    def createObject(self, stream):
        """
        createObject(Transition self, XMLInputStream stream) -> SBase


        Create and return an SBML object of this class, if present.

        Returns the SBML object corresponding to next XMLToken in the
        XMLInputStream or 'None' if the token was not recognized.

        """
        return _libsbml.Transition_createObject(self, stream)


    def addExpectedAttributes(self, attributes):
        """
        addExpectedAttributes(Transition self, ExpectedAttributes & attributes)


        Get the list of expected attributes for this element.

        """
        return _libsbml.Transition_addExpectedAttributes(self, attributes)


    def readAttributes(self, attributes, expectedAttributes):
        """
        readAttributes(Transition self, XMLAttributes attributes, ExpectedAttributes const & expectedAttributes)


        Internal implementation method.

        """
        return _libsbml.Transition_readAttributes(self, attributes, expectedAttributes)


    def writeAttributes(self, stream):
        """
        writeAttributes(Transition self, XMLOutputStream stream)


        Internal implementation method.

        """
        return _libsbml.Transition_writeAttributes(self, stream)

Transition_swigregister = _libsbml.Transition_swigregister
Transition_swigregister(Transition)

class ListOfTransitions(ListOf):
    """

    [SBML 'qual' package]

    A list of Transition objects.

    The ListOfTransitions is a container for the Transition elements of a
    Model.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    See also Transition.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfTransitions, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfTransitions, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ListOfTransitions self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ListOfTransitions
        __init__(ListOfTransitions self, unsigned int level, unsigned int version) -> ListOfTransitions
        __init__(ListOfTransitions self, unsigned int level) -> ListOfTransitions
        __init__(ListOfTransitions self) -> ListOfTransitions
        __init__(ListOfTransitions self, QualPkgNamespaces qualns) -> ListOfTransitions


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfTransitions(long level      =
        QualExtension.getDefaultLevel(), long version    =
        QualExtension.getDefaultVersion(), long pkgVersion =
        QualExtension.getDefaultPackageVersion())

        Creates a new ListOfTransitions with the given level, version, and
        package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        ListOfTransitions.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this ListOfTransitions.

        Parameter 'pkgVersion' is a long integer, the SBML Qual Version to
        assign to this ListOfTransitions.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfTransitions(QualPkgNamespaces qualns)

        Creates a new ListOfTransitions with the given QualPkgNamespaces
        object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'qualns' is the QualPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_ListOfTransitions(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ListOfTransitions self) -> ListOfTransitions


        Creates and returns a deep copy of this ListOfTransitions object.

        Returns a (deep) copy of this ListOfTransitions object.

        """
        return _libsbml.ListOfTransitions_clone(self)


    def get(self, *args):
        """
        get(ListOfTransitions self, unsigned int n) -> Transition
        get(ListOfTransitions self, unsigned int n) -> Transition
        get(ListOfTransitions self, string sid) -> Transition
        get(ListOfTransitions self, string sid) -> Transition


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a Transition from the ListOfTransitions.

        Parameter 'n' is the index number of the Transition to get.

        Returns the nth Transition in this ListOfTransitions. If the index 'n'
        is invalid, 'None' is returned.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a Transition from the ListOfTransitions based on its identifier.

        Parameter 'sid' is a string representing the identifier of the
        Transition to get.

        Returns Transition in this ListOfTransitions with the given id or
        'None' if no such Transition exists.

        See also get()   *, size().

        """
        return _libsbml.ListOfTransitions_get(self, *args)


    def remove(self, *args):
        """
        remove(ListOfTransitions self, unsigned int n) -> Transition
        remove(ListOfTransitions self, string sid) -> Transition


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth Transition from this ListOfTransitions and returns a
        pointer to it.

        The caller owns the returned item and is responsible for deleting it.

        Parameter 'n' is the index of the Transition to remove.

        See also size().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes the Transition from this ListOfTransitions with the given
        identifier and returns a pointer to it.

        The caller owns the returned item and is responsible for deleting it.
        If none of the items in this list have the identifier 'sid', then
        'None' is returned.

        Parameter 'sid' is the identifier of the Transition to remove.

        Returns the Transition removed. As mentioned above, the caller owns
        the returned item.

        """
        return _libsbml.ListOfTransitions_remove(self, *args)


    def getElementName(self):
        """
        getElementName(ListOfTransitions self) -> string


        Returns the XML name of this object.

        Returns the name of this element.

        """
        return _libsbml.ListOfTransitions_getElementName(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfTransitions self) -> int


        Returns the libSBML type code for the SBML objects contained in this
        ListOf object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for objects contained in this list:
        SBML_QUAL_TRANSITION (default).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfTransitions_getItemTypeCode(self)

    __swig_destroy__ = _libsbml.delete_ListOfTransitions
    __del__ = lambda self: None
ListOfTransitions_swigregister = _libsbml.ListOfTransitions_swigregister
ListOfTransitions_swigregister(ListOfTransitions)

QualUnknown = _libsbml.QualUnknown
QualNSUndeclared = _libsbml.QualNSUndeclared
QualElementNotInNs = _libsbml.QualElementNotInNs
QualFunctionTermBool = _libsbml.QualFunctionTermBool
QualMathCSymbolDisallowed = _libsbml.QualMathCSymbolDisallowed
QualDuplicateComponentId = _libsbml.QualDuplicateComponentId
QualAttributeRequiredMissing = _libsbml.QualAttributeRequiredMissing
QualAttributeRequiredMustBeBoolean = _libsbml.QualAttributeRequiredMustBeBoolean
QualRequiredTrueIfTransitions = _libsbml.QualRequiredTrueIfTransitions
QualOneListOfTransOrQS = _libsbml.QualOneListOfTransOrQS
QualEmptyLONotAllowed = _libsbml.QualEmptyLONotAllowed
QualLOTransitiondAllowedElements = _libsbml.QualLOTransitiondAllowedElements
QualLOQualSpeciesAllowedElements = _libsbml.QualLOQualSpeciesAllowedElements
QualLOQualSpeciesAllowedAttributes = _libsbml.QualLOQualSpeciesAllowedAttributes
QualLOTransitionsAllowedAttributes = _libsbml.QualLOTransitionsAllowedAttributes
QualQualSpeciesAllowedCoreAttributes = _libsbml.QualQualSpeciesAllowedCoreAttributes
QualQualSpeciesAllowedElements = _libsbml.QualQualSpeciesAllowedElements
QualQualSpeciesAllowedAttributes = _libsbml.QualQualSpeciesAllowedAttributes
QualConstantMustBeBool = _libsbml.QualConstantMustBeBool
QualNameMustBeString = _libsbml.QualNameMustBeString
QualInitialLevelMustBeInt = _libsbml.QualInitialLevelMustBeInt
QualMaxLevelMustBeInt = _libsbml.QualMaxLevelMustBeInt
QualCompartmentMustReferExisting = _libsbml.QualCompartmentMustReferExisting
QualInitialLevelCannotExceedMax = _libsbml.QualInitialLevelCannotExceedMax
QualConstantQSCannotBeOutput = _libsbml.QualConstantQSCannotBeOutput
QualQSAssignedOnlyOnce = _libsbml.QualQSAssignedOnlyOnce
QualInitalLevelNotNegative = _libsbml.QualInitalLevelNotNegative
QualMaxLevelNotNegative = _libsbml.QualMaxLevelNotNegative
QualTransitionAllowedCoreAttributes = _libsbml.QualTransitionAllowedCoreAttributes
QualTransitionAllowedElements = _libsbml.QualTransitionAllowedElements
QualTransitionAllowedAttributes = _libsbml.QualTransitionAllowedAttributes
QualTransitionNameMustBeString = _libsbml.QualTransitionNameMustBeString
QualTransitionLOElements = _libsbml.QualTransitionLOElements
QualTransitionEmptyLOElements = _libsbml.QualTransitionEmptyLOElements
QualTransitionLOInputElements = _libsbml.QualTransitionLOInputElements
QualTransitionLOOutputElements = _libsbml.QualTransitionLOOutputElements
QualTransitionLOFuncTermElements = _libsbml.QualTransitionLOFuncTermElements
QualTransitionLOInputAttributes = _libsbml.QualTransitionLOInputAttributes
QualTransitionLOOutputAttributes = _libsbml.QualTransitionLOOutputAttributes
QualTransitionLOFuncTermAttributes = _libsbml.QualTransitionLOFuncTermAttributes
QualTransitionLOFuncTermExceedMax = _libsbml.QualTransitionLOFuncTermExceedMax
QualTransitionLOFuncTermNegative = _libsbml.QualTransitionLOFuncTermNegative
QualInputAllowedCoreAttributes = _libsbml.QualInputAllowedCoreAttributes
QualInputAllowedElements = _libsbml.QualInputAllowedElements
QualInputAllowedAttributes = _libsbml.QualInputAllowedAttributes
QualInputNameMustBeString = _libsbml.QualInputNameMustBeString
QualInputSignMustBeSignEnum = _libsbml.QualInputSignMustBeSignEnum
QualInputTransEffectMustBeInputEffect = _libsbml.QualInputTransEffectMustBeInputEffect
QualInputThreshMustBeInteger = _libsbml.QualInputThreshMustBeInteger
QualInputQSMustBeExistingQS = _libsbml.QualInputQSMustBeExistingQS
QualInputConstantCannotBeConsumed = _libsbml.QualInputConstantCannotBeConsumed
QualInputThreshMustBeNonNegative = _libsbml.QualInputThreshMustBeNonNegative
QualOutputAllowedCoreAttributes = _libsbml.QualOutputAllowedCoreAttributes
QualOutputAllowedElements = _libsbml.QualOutputAllowedElements
QualOutputAllowedAttributes = _libsbml.QualOutputAllowedAttributes
QualOutputNameMustBeString = _libsbml.QualOutputNameMustBeString
QualOutputTransEffectMustBeOutput = _libsbml.QualOutputTransEffectMustBeOutput
QualOutputLevelMustBeInteger = _libsbml.QualOutputLevelMustBeInteger
QualOutputQSMustBeExistingQS = _libsbml.QualOutputQSMustBeExistingQS
QualOutputConstantMustBeFalse = _libsbml.QualOutputConstantMustBeFalse
QualOutputProductionMustHaveLevel = _libsbml.QualOutputProductionMustHaveLevel
QualOutputLevelMustBeNonNegative = _libsbml.QualOutputLevelMustBeNonNegative
QualDefaultTermAllowedCoreAttributes = _libsbml.QualDefaultTermAllowedCoreAttributes
QualDefaultTermAllowedElements = _libsbml.QualDefaultTermAllowedElements
QualDefaultTermAllowedAttributes = _libsbml.QualDefaultTermAllowedAttributes
QualDefaultTermResultMustBeInteger = _libsbml.QualDefaultTermResultMustBeInteger
QualDefaultTermResultMustBeNonNeg = _libsbml.QualDefaultTermResultMustBeNonNeg
QualFuncTermAllowedCoreAttributes = _libsbml.QualFuncTermAllowedCoreAttributes
QualFuncTermAllowedElements = _libsbml.QualFuncTermAllowedElements
QualFuncTermAllowedAttributes = _libsbml.QualFuncTermAllowedAttributes
QualFuncTermOnlyOneMath = _libsbml.QualFuncTermOnlyOneMath
QualFuncTermResultMustBeInteger = _libsbml.QualFuncTermResultMustBeInteger
QualFuncTermResultMustBeNonNeg = _libsbml.QualFuncTermResultMustBeNonNeg
class RenderPkgNamespaces(SBMLNamespaces):
    """

    Set of SBML Level + Version + namespace triples.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    SBMLExtensionNamespaces is a template class.  It is extended from
    SBMLNamespaces and is meant to be used by package extensions to store
    the SBML Level, Version within a Level, and package version of the
    SBML Level 3 package implemented by a libSBML package extension.

    Basic principles of SBML package extensions in libSBML
    ======================================================================

    SBML Level 3's package structure permits modular extensions to the
    core SBML format.  In libSBML, support for SBML Level 3 packages is
    provided through optional package extensions that can be plugged into
    libSBML at the time it is built/compiled.  Users of libSBML can thus
    choose which extensions are enabled in their software applications.

    LibSBML defines a number of classes that developers of package
    extensions can use to implement support for an SBML Level 3 package.
    These classes make it easier to extend libSBML objects with new
    attributes and/or subobjects as needed by a particular Level 3
    package. Three overall categories of classes make up libSBML's
    facilities for implementing package extensions.  There are (1) classes
    that serve as base classes meant to be subclassed, (2) template
    classes meant to be instantiated rather than subclassed, and (3)
    support classes that provide utility features. A given package
    implementation for libSBML will take the form of code using these and
    other libSBML classes, placed in a subdirectory of src/sbml/packages/.

    The basic libSBML distribution includes a number of package extensions
    implementing support for officially-endorsed SBML Level 3 packages;
    among these are Flux Balance Constraints ('fbc'), Hierarchical Model
    Composition ('comp'), Layout ('layout'), and Qualitative Models
    ('qual').  They can serve as working examples for developers working
    to implement other packages.

    Extensions in libSBML can currently only be implemented in C++ or C;
    there is no mechanism to implement them first in languages such as
    Java or Python.  However, once implemented in C++ or C, language
    interfaces can be generated semi-automatically using the framework in
    place in libSBML.  (The approach is based on using SWIG and facilities
    in libSBML's build system.)

    """

    __swig_setmethods__ = {}
    for _s in [SBMLNamespaces]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RenderPkgNamespaces, name, value)
    __swig_getmethods__ = {}
    for _s in [SBMLNamespaces]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, RenderPkgNamespaces, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _libsbml.delete_RenderPkgNamespaces
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(SBMLExtensionNamespaces<(RenderExtension)> self, unsigned int level, unsigned int version, unsigned int pkgVersion, string prefix) -> RenderPkgNamespaces
        __init__(SBMLExtensionNamespaces<(RenderExtension)> self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> RenderPkgNamespaces
        __init__(SBMLExtensionNamespaces<(RenderExtension)> self, unsigned int level, unsigned int version) -> RenderPkgNamespaces
        __init__(SBMLExtensionNamespaces<(RenderExtension)> self, unsigned int level) -> RenderPkgNamespaces
        __init__(SBMLExtensionNamespaces<(RenderExtension)> self) -> RenderPkgNamespaces
        __init__(SBMLExtensionNamespaces<(RenderExtension)> self, RenderPkgNamespaces orig) -> RenderPkgNamespaces


        Set of SBML Level + Version + namespace triples.

        This class of objects is defined by libSBML only and has no direct
        equivalent in terms of SBML components.  This class is not prescribed
        by the SBML specifications, although it is used to implement features
        defined in SBML.

        SBMLExtensionNamespaces is a template class.  It is extended from
        SBMLNamespaces and is meant to be used by package extensions to store
        the SBML Level, Version within a Level, and package version of the
        SBML Level 3 package implemented by a libSBML package extension.

        Basic principles of SBML package extensions in libSBML
        ======================================================================

        SBML Level 3's package structure permits modular extensions to the
        core SBML format.  In libSBML, support for SBML Level 3 packages is
        provided through optional package extensions that can be plugged into
        libSBML at the time it is built/compiled.  Users of libSBML can thus
        choose which extensions are enabled in their software applications.

        LibSBML defines a number of classes that developers of package
        extensions can use to implement support for an SBML Level 3 package.
        These classes make it easier to extend libSBML objects with new
        attributes and/or subobjects as needed by a particular Level 3
        package. Three overall categories of classes make up libSBML's
        facilities for implementing package extensions.  There are (1) classes
        that serve as base classes meant to be subclassed, (2) template
        classes meant to be instantiated rather than subclassed, and (3)
        support classes that provide utility features. A given package
        implementation for libSBML will take the form of code using these and
        other libSBML classes, placed in a subdirectory of src/sbml/packages/.

        The basic libSBML distribution includes a number of package extensions
        implementing support for officially-endorsed SBML Level 3 packages;
        among these are Flux Balance Constraints ('fbc'), Hierarchical Model
        Composition ('comp'), Layout ('layout'), and Qualitative Models
        ('qual').  They can serve as working examples for developers working
        to implement other packages.

        Extensions in libSBML can currently only be implemented in C++ or C;
        there is no mechanism to implement them first in languages such as
        Java or Python.  However, once implemented in C++ or C, language
        interfaces can be generated semi-automatically using the framework in
        place in libSBML.  (The approach is based on using SWIG and facilities
        in libSBML's build system.)

        """
        this = _libsbml.new_RenderPkgNamespaces(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(RenderPkgNamespaces self) -> ISBMLExtensionNamespaces


        Creates and returns a deep copy of this SBMLNamespaces object.

        Returns the (deep) copy of this SBMLNamespaces object.

        """
        return _libsbml.RenderPkgNamespaces_clone(self)


    def getURI(self):
        """
        getURI(RenderPkgNamespaces self) -> string


        Returns a string representing the SBML XML namespace of this object.

        Returns a string representing the SBML namespace that reflects the
        SBML Level and Version of this object.

        """
        return _libsbml.RenderPkgNamespaces_getURI(self)


    def getPackageVersion(self):
        """getPackageVersion(RenderPkgNamespaces self) -> unsigned int"""
        return _libsbml.RenderPkgNamespaces_getPackageVersion(self)


    def getPackageName(self):
        """
        getPackageName(RenderPkgNamespaces self) -> string


        Returns the name of the main package for this namespace.

        Returns the name of the main package for this namespace. 'core' will
        be returned if this namespace is defined in the SBML  core.

        """
        return _libsbml.RenderPkgNamespaces_getPackageName(self)

RenderPkgNamespaces_swigregister = _libsbml.RenderPkgNamespaces_swigregister
RenderPkgNamespaces_swigregister(RenderPkgNamespaces)

class RenderExtension(SBMLExtension):
    """

    [SBML 'render' package]

    Base extension class for the package.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    """

    __swig_setmethods__ = {}
    for _s in [SBMLExtension]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RenderExtension, name, value)
    __swig_getmethods__ = {}
    for _s in [SBMLExtension]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, RenderExtension, name)
    __repr__ = _swig_repr

    def getPackageName():
        """
        getPackageName() -> string


        Returns the package name of this extension.

        """
        return _libsbml.RenderExtension_getPackageName()

    getPackageName = staticmethod(getPackageName)

    def getDefaultLevel():
        """
        getDefaultLevel() -> unsigned int


        Returns the default SBML Level this extension.

        """
        return _libsbml.RenderExtension_getDefaultLevel()

    getDefaultLevel = staticmethod(getDefaultLevel)

    def getDefaultVersion():
        """
        getDefaultVersion() -> unsigned int


        Returns the default SBML Version this extension.

        """
        return _libsbml.RenderExtension_getDefaultVersion()

    getDefaultVersion = staticmethod(getDefaultVersion)

    def getDefaultPackageVersion():
        """
        getDefaultPackageVersion() -> unsigned int


        Returns the default SBML version this extension.

        """
        return _libsbml.RenderExtension_getDefaultPackageVersion()

    getDefaultPackageVersion = staticmethod(getDefaultPackageVersion)

    def getXmlnsL3V1V1():
        """
        getXmlnsL3V1V1() -> string


        Returns URI of supported versions of this package.

        """
        return _libsbml.RenderExtension_getXmlnsL3V1V1()

    getXmlnsL3V1V1 = staticmethod(getXmlnsL3V1V1)

    def getXmlnsL2():
        """
        getXmlnsL2() -> string


        Returns URI of L2 version of supported versions of this package.

        """
        return _libsbml.RenderExtension_getXmlnsL2()

    getXmlnsL2 = staticmethod(getXmlnsL2)

    def __init__(self, *args):
        """
        __init__(RenderExtension self) -> RenderExtension
        __init__(RenderExtension self, RenderExtension arg2) -> RenderExtension


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            RenderExtension(RenderExtension)

        Copy constructor.

        ______________________________________________________________________
        Method variant with the following signature:

            RenderExtension()

        Constructor

        """
        this = _libsbml.new_RenderExtension(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_RenderExtension
    __del__ = lambda self: None

    def clone(self):
        """
        clone(RenderExtension self) -> RenderExtension


        Creates and returns a deep copy of this RenderExtension object.

        Returns a (deep) copy of this RenderExtension object

        """
        return _libsbml.RenderExtension_clone(self)


    def getName(self):
        """
        getName(RenderExtension self) -> string


        Returns the name of this package ('render')

        """
        return _libsbml.RenderExtension_getName(self)


    def getURI(self, sbmlLevel, sbmlVersion, pkgVersion):
        """
        getURI(RenderExtension self, unsigned int sbmlLevel, unsigned int sbmlVersion, unsigned int pkgVersion) -> string


        Returns the URI (namespace) of the package corresponding to the
        combination of  the given sbml level, sbml version, and package
        version. Empty string will be returned if no corresponding URI exists.

        Parameter 'sbmlLevel' is the level of SBML Parameter 'sbmlVersion' is
        the version of SBML Parameter 'pkgVersion' is the version of package

        Returns a string of the package URI

        """
        return _libsbml.RenderExtension_getURI(self, sbmlLevel, sbmlVersion, pkgVersion)


    def getLevel(self, uri):
        """
        getLevel(RenderExtension self, string uri) -> unsigned int


        Returns the SBML level with the given URI of this package.

        Parameter 'uri' is the string of URI that represents one of the
        versions of the render package

        Returns the SBML level with the given URI of this package. 0 will be
        returned if the given URI is invalid.

        """
        return _libsbml.RenderExtension_getLevel(self, uri)


    def getVersion(self, uri):
        """
        getVersion(RenderExtension self, string uri) -> unsigned int


        Returns the SBML version with the given URI of this package.

        Parameter 'uri' is the string of URI that represents one of the
        versions of the render package

        Returns the SBML version with the given URI of this package. 0 will be
        returned if the given URI is invalid.

        """
        return _libsbml.RenderExtension_getVersion(self, uri)


    def getPackageVersion(self, uri):
        """
        getPackageVersion(RenderExtension self, string uri) -> unsigned int


        Returns the package version with the given URI of this package.

        Parameter 'uri' is the string of URI that represents one of the
        versions of the render package

        Returns the package version with the given URI of this package. 0 will
        be returned if the given URI is invalid.

        """
        return _libsbml.RenderExtension_getPackageVersion(self, uri)


    def getSBMLExtensionNamespaces(self, uri):
        """
        getSBMLExtensionNamespaces(RenderExtension self, string uri) -> SBMLNamespaces


        Returns a RenderPkgNamespaces object. 'None' will be returned if the
        given uri is not defined in the render package.

        Parameter 'uri' is the string of URI that represents one of the
        versions of the render package

        Returns a RenderPkgNamespaces object corresponding to the given uri.
        'None' will be returned if the given URI is not defined in render
        package.

        """
        return _libsbml.RenderExtension_getSBMLExtensionNamespaces(self, uri)


    def getStringFromTypeCode(self, typeCode):
        """
        getStringFromTypeCode(RenderExtension self, int typeCode) -> char const *


        This method takes a type code of groups package and returns a string
        representing  the code.

        """
        return _libsbml.RenderExtension_getStringFromTypeCode(self, typeCode)


    def getErrorTable(self, index):
        """
        getErrorTable(RenderExtension self, unsigned int index) -> packageErrorTableEntry


        Internal implementation method.

        """
        return _libsbml.RenderExtension_getErrorTable(self, index)


    def getErrorTableIndex(self, errorId):
        """
        getErrorTableIndex(RenderExtension self, unsigned int errorId) -> unsigned int


        Internal implementation method.

        """
        return _libsbml.RenderExtension_getErrorTableIndex(self, errorId)


    def getErrorIdOffset(self):
        """
        getErrorIdOffset(RenderExtension self) -> unsigned int


        Internal implementation method.

        """
        return _libsbml.RenderExtension_getErrorIdOffset(self)


    def init():
        """
        init()


        Internal implementation method.

        """
        return _libsbml.RenderExtension_init()

    init = staticmethod(init)

    def removeL2Namespaces(self, xmlns):
        """
        removeL2Namespaces(RenderExtension self, XMLNamespaces xmlns)


        Removes the L2 Namespace from a document.

        This method is overridden here since Render does serialize to an L2
        annotation.

        """
        return _libsbml.RenderExtension_removeL2Namespaces(self, xmlns)


    def addL2Namespaces(self, xmlns):
        """
        addL2Namespaces(RenderExtension self, XMLNamespaces xmlns)


        adds all L2 Extension namespaces to the namespace list.

        This method is overridden here since Render does serialize to an L2
        annotation.

        """
        return _libsbml.RenderExtension_addL2Namespaces(self, xmlns)


    def enableL2NamespaceForDocument(self, doc):
        """
        enableL2NamespaceForDocument(RenderExtension self, SBMLDocument doc)


        Adds the L2 Namespace to the document and enables the extension.

        This method is overridden here since Render does serialize to an L2
        annotation.

        """
        return _libsbml.RenderExtension_enableL2NamespaceForDocument(self, doc)


    def isInUse(self, doc):
        """
        isInUse(RenderExtension self, SBMLDocument doc) -> bool


        Determines whether this extension is being used by the given
        SBMLDocument

        The implementation returns 'True' if the list of layouts contains a
        global render information, or a layout object contains a local render
        information object.

        Parameter 'doc' is the sbml document to test.

        Returns a boolean indicating whether the extension is actually being
        used byy the document.

        """
        return _libsbml.RenderExtension_isInUse(self, doc)

RenderExtension_swigregister = _libsbml.RenderExtension_swigregister
RenderExtension_swigregister(RenderExtension)

def RenderExtension_getPackageName():
    """
    RenderExtension_getPackageName() -> string


    Returns the package name of this extension.

    """
    return _libsbml.RenderExtension_getPackageName()

def RenderExtension_getDefaultLevel():
    """
    RenderExtension_getDefaultLevel() -> unsigned int


    Returns the default SBML Level this extension.

    """
    return _libsbml.RenderExtension_getDefaultLevel()

def RenderExtension_getDefaultVersion():
    """
    RenderExtension_getDefaultVersion() -> unsigned int


    Returns the default SBML Version this extension.

    """
    return _libsbml.RenderExtension_getDefaultVersion()

def RenderExtension_getDefaultPackageVersion():
    """
    RenderExtension_getDefaultPackageVersion() -> unsigned int


    Returns the default SBML version this extension.

    """
    return _libsbml.RenderExtension_getDefaultPackageVersion()

def RenderExtension_getXmlnsL3V1V1():
    """
    RenderExtension_getXmlnsL3V1V1() -> string


    Returns URI of supported versions of this package.

    """
    return _libsbml.RenderExtension_getXmlnsL3V1V1()

def RenderExtension_getXmlnsL2():
    """
    RenderExtension_getXmlnsL2() -> string


    Returns URI of L2 version of supported versions of this package.

    """
    return _libsbml.RenderExtension_getXmlnsL2()

def RenderExtension_init():
    """
    RenderExtension_init()


    Internal implementation method.

    """
    return _libsbml.RenderExtension_init()

SBML_RENDER_COLORDEFINITION = _libsbml.SBML_RENDER_COLORDEFINITION
SBML_RENDER_ELLIPSE = _libsbml.SBML_RENDER_ELLIPSE
SBML_RENDER_GLOBALRENDERINFORMATION = _libsbml.SBML_RENDER_GLOBALRENDERINFORMATION
SBML_RENDER_GLOBALSTYLE = _libsbml.SBML_RENDER_GLOBALSTYLE
SBML_RENDER_GRADIENTDEFINITION = _libsbml.SBML_RENDER_GRADIENTDEFINITION
SBML_RENDER_GRADIENT_STOP = _libsbml.SBML_RENDER_GRADIENT_STOP
SBML_RENDER_GROUP = _libsbml.SBML_RENDER_GROUP
SBML_RENDER_IMAGE = _libsbml.SBML_RENDER_IMAGE
SBML_RENDER_LINEENDING = _libsbml.SBML_RENDER_LINEENDING
SBML_RENDER_LINEARGRADIENT = _libsbml.SBML_RENDER_LINEARGRADIENT
SBML_RENDER_LINESEGMENT = _libsbml.SBML_RENDER_LINESEGMENT
SBML_RENDER_LISTOFGLOBALSTYLES = _libsbml.SBML_RENDER_LISTOFGLOBALSTYLES
SBML_RENDER_LISTOFLOCALSTYLES = _libsbml.SBML_RENDER_LISTOFLOCALSTYLES
SBML_RENDER_LOCALRENDERINFORMATION = _libsbml.SBML_RENDER_LOCALRENDERINFORMATION
SBML_RENDER_LOCALSTYLE = _libsbml.SBML_RENDER_LOCALSTYLE
SBML_RENDER_POLYGON = _libsbml.SBML_RENDER_POLYGON
SBML_RENDER_RADIALGRADIENT = _libsbml.SBML_RENDER_RADIALGRADIENT
SBML_RENDER_RECTANGLE = _libsbml.SBML_RENDER_RECTANGLE
SBML_RENDER_RELABSVECTOR = _libsbml.SBML_RENDER_RELABSVECTOR
SBML_RENDER_CUBICBEZIER = _libsbml.SBML_RENDER_CUBICBEZIER
SBML_RENDER_CURVE = _libsbml.SBML_RENDER_CURVE
SBML_RENDER_POINT = _libsbml.SBML_RENDER_POINT
SBML_RENDER_TEXT = _libsbml.SBML_RENDER_TEXT
SBML_RENDER_TRANSFORMATION2D = _libsbml.SBML_RENDER_TRANSFORMATION2D
SBML_RENDER_DEFAULTS = _libsbml.SBML_RENDER_DEFAULTS
SBML_RENDER_TRANSFORMATION = _libsbml.SBML_RENDER_TRANSFORMATION
SBML_RENDER_GRAPHICALPRIMITIVE1D = _libsbml.SBML_RENDER_GRAPHICALPRIMITIVE1D
SBML_RENDER_GRAPHICALPRIMITIVE2D = _libsbml.SBML_RENDER_GRAPHICALPRIMITIVE2D
SBML_RENDER_STYLE_BASE = _libsbml.SBML_RENDER_STYLE_BASE
SBML_RENDER_RENDERINFORMATION_BASE = _libsbml.SBML_RENDER_RENDERINFORMATION_BASE
GRADIENT_SPREADMETHOD_PAD = _libsbml.GRADIENT_SPREADMETHOD_PAD
GRADIENT_SPREADMETHOD_REFLECT = _libsbml.GRADIENT_SPREADMETHOD_REFLECT
GRADIENT_SPREADMETHOD_REPEAT = _libsbml.GRADIENT_SPREADMETHOD_REPEAT
GRADIENT_SPREAD_METHOD_INVALID = _libsbml.GRADIENT_SPREAD_METHOD_INVALID
FILL_RULE_UNSET = _libsbml.FILL_RULE_UNSET
FILL_RULE_NONZERO = _libsbml.FILL_RULE_NONZERO
FILL_RULE_EVENODD = _libsbml.FILL_RULE_EVENODD
FILL_RULE_INHERIT = _libsbml.FILL_RULE_INHERIT
FILL_RULE_INVALID = _libsbml.FILL_RULE_INVALID
FONT_FAMILY_SERIF = _libsbml.FONT_FAMILY_SERIF
FONT_FAMILY_SANS_SERIF = _libsbml.FONT_FAMILY_SANS_SERIF
FONT_FAMILY_MONOSPACE = _libsbml.FONT_FAMILY_MONOSPACE
FONT_FAMILY_INVALID = _libsbml.FONT_FAMILY_INVALID
FONT_WEIGHT_UNSET = _libsbml.FONT_WEIGHT_UNSET
FONT_WEIGHT_NORMAL = _libsbml.FONT_WEIGHT_NORMAL
FONT_WEIGHT_BOLD = _libsbml.FONT_WEIGHT_BOLD
FONT_WEIGHT_INVALID = _libsbml.FONT_WEIGHT_INVALID
FONT_STYLE_UNSET = _libsbml.FONT_STYLE_UNSET
FONT_STYLE_NORMAL = _libsbml.FONT_STYLE_NORMAL
FONT_STYLE_ITALIC = _libsbml.FONT_STYLE_ITALIC
FONT_STYLE_INVALID = _libsbml.FONT_STYLE_INVALID
V_TEXTANCHOR_UNSET = _libsbml.V_TEXTANCHOR_UNSET
V_TEXTANCHOR_TOP = _libsbml.V_TEXTANCHOR_TOP
V_TEXTANCHOR_MIDDLE = _libsbml.V_TEXTANCHOR_MIDDLE
V_TEXTANCHOR_BOTTOM = _libsbml.V_TEXTANCHOR_BOTTOM
V_TEXTANCHOR_BASELINE = _libsbml.V_TEXTANCHOR_BASELINE
V_TEXTANCHOR_INVALID = _libsbml.V_TEXTANCHOR_INVALID
H_TEXTANCHOR_UNSET = _libsbml.H_TEXTANCHOR_UNSET
H_TEXTANCHOR_START = _libsbml.H_TEXTANCHOR_START
H_TEXTANCHOR_MIDDLE = _libsbml.H_TEXTANCHOR_MIDDLE
H_TEXTANCHOR_END = _libsbml.H_TEXTANCHOR_END
H_TEXTANCHOR_INVALID = _libsbml.H_TEXTANCHOR_INVALID
class RenderListOfLayoutsPlugin(SBasePlugin):
    """

    [SBML 'render' package]

    A list of layout objects used by the 'render' extension.

    The Render package extends the ListOfLayouts object from the Layout
    package  with the addition of an optional
    ListOfGlobalRenderInformation object.

    """

    __swig_setmethods__ = {}
    for _s in [SBasePlugin]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RenderListOfLayoutsPlugin, name, value)
    __swig_getmethods__ = {}
    for _s in [SBasePlugin]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, RenderListOfLayoutsPlugin, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(RenderListOfLayoutsPlugin self, string uri, string prefix, RenderPkgNamespaces groupsns) -> RenderListOfLayoutsPlugin
        __init__(RenderListOfLayoutsPlugin self, RenderListOfLayoutsPlugin orig) -> RenderListOfLayoutsPlugin


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            RenderListOfLayoutsPlugin(RenderListOfLayoutsPlugin  orig)

        Copy constructor. Creates a copy of this SBase object.

        ______________________________________________________________________
        Method variant with the following signature:

            RenderListOfLayoutsPlugin(string &uri, string &prefix,
        RenderPkgNamespaces groupsns)

        Constructor

        """
        this = _libsbml.new_RenderListOfLayoutsPlugin(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_RenderListOfLayoutsPlugin
    __del__ = lambda self: None

    def clone(self):
        """
        clone(RenderListOfLayoutsPlugin self) -> RenderListOfLayoutsPlugin


        Creates and returns a deep copy of this RenderListOfLayoutsPlugin
        object.

        Returns a (deep) copy of this RenderListOfLayoutsPlugin object

        """
        return _libsbml.RenderListOfLayoutsPlugin_clone(self)


    def hasRequiredElements(self):
        """
        hasRequiredElements(RenderListOfLayoutsPlugin self) -> bool


        Internal implementation method.

        """
        return _libsbml.RenderListOfLayoutsPlugin_hasRequiredElements(self)


    def appendFrom(self, model):
        """
        appendFrom(RenderListOfLayoutsPlugin self, Model model) -> int


        Internal implementation method.

        """
        return _libsbml.RenderListOfLayoutsPlugin_appendFrom(self, model)


    def getListOfGlobalRenderInformation(self, *args):
        """
        getListOfGlobalRenderInformation(RenderListOfLayoutsPlugin self) -> ListOfGlobalRenderInformation
        getListOfGlobalRenderInformation(RenderListOfLayoutsPlugin self) -> ListOfGlobalRenderInformation


        Returns a pointer to the list object that contains local render
        information.

        """
        return _libsbml.RenderListOfLayoutsPlugin_getListOfGlobalRenderInformation(self, *args)


    def getNumGlobalRenderInformationObjects(self):
        """
        getNumGlobalRenderInformationObjects(RenderListOfLayoutsPlugin self) -> unsigned int


        Returns the number of local render information objects.

        """
        return _libsbml.RenderListOfLayoutsPlugin_getNumGlobalRenderInformationObjects(self)


    def getRenderInformation(self, *args):
        """
        getRenderInformation(RenderListOfLayoutsPlugin self, unsigned int index) -> GlobalRenderInformation
        getRenderInformation(RenderListOfLayoutsPlugin self, unsigned int index) -> GlobalRenderInformation
        getRenderInformation(RenderListOfLayoutsPlugin self, string id) -> GlobalRenderInformation
        getRenderInformation(RenderListOfLayoutsPlugin self, string id) -> GlobalRenderInformation


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getRenderInformation(long index)

        Returns a  pointer to the local render information object with the
        given index. If the index is invalid, 'None' is returned.

        ______________________________________________________________________
        Method variant with the following signature:

            getRenderInformation(string id)

        Returns a  pointer to the local render information object with the
        given id. If no object with the given 'id' exists, 'None' is returned.

        """
        return _libsbml.RenderListOfLayoutsPlugin_getRenderInformation(self, *args)


    def addGlobalRenderInformation(self, pLRI):
        """
        addGlobalRenderInformation(RenderListOfLayoutsPlugin self, GlobalRenderInformation pLRI)


        Adds a copy of the given local render information object to the list
        of local render information objects. If an object with the same id
        exists, it is replaced.

        """
        return _libsbml.RenderListOfLayoutsPlugin_addGlobalRenderInformation(self, pLRI)


    def createGlobalRenderInformation(self):
        """
        createGlobalRenderInformation(RenderListOfLayoutsPlugin self) -> GlobalRenderInformation


        Creates a new local render information object and adds it to the list.
        The created object does not have a id and it is the responsibility of
        the calling code to ensure that it gets one. For constraints on the
        id, please consult the render information document.

        """
        return _libsbml.RenderListOfLayoutsPlugin_createGlobalRenderInformation(self)


    def removeGlobalRenderInformation(self, *args):
        """
        removeGlobalRenderInformation(RenderListOfLayoutsPlugin self, unsigned int index) -> GlobalRenderInformation
        removeGlobalRenderInformation(RenderListOfLayoutsPlugin self, string id) -> GlobalRenderInformation


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeGlobalRenderInformation(long index)

        Removed the render information with the given index from the list. The
        removed object is returned. It is the responsibility of the calling
        code to delete the object. If the index is not valid, 'None' is
        returned.

        ______________________________________________________________________
        Method variant with the following signature:

            removeGlobalRenderInformation(string id)

        Removed the render information with the given 'id' from the list. The
        removed object is returned. It is the responsibility of the calling
        code to delete the object. If an object with the given 'id' does not
        exist, 'None' is returned.

        """
        return _libsbml.RenderListOfLayoutsPlugin_removeGlobalRenderInformation(self, *args)


    def connectToParent(self, sbase):
        """
        connectToParent(RenderListOfLayoutsPlugin self, SBase sbase)


        Internal implementation method.

        """
        return _libsbml.RenderListOfLayoutsPlugin_connectToParent(self, sbase)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(RenderListOfLayoutsPlugin self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.RenderListOfLayoutsPlugin_enablePackageInternal(self, pkgURI, pkgPrefix, flag)


    def parseAnnotation(self):
        """parseAnnotation(RenderListOfLayoutsPlugin self)"""
        return _libsbml.RenderListOfLayoutsPlugin_parseAnnotation(self)

RenderListOfLayoutsPlugin_swigregister = _libsbml.RenderListOfLayoutsPlugin_swigregister
RenderListOfLayoutsPlugin_swigregister(RenderListOfLayoutsPlugin)

class RenderLayoutPlugin(SBasePlugin):
    """

    [SBML 'render' package]

    LibSBML implementation for the extension to the Layout class by the
    Render extension.

    The Render package extends the Layout object from the Layout package
    with the addition of an optional ListOfLocalRenderInformation object.

    """

    __swig_setmethods__ = {}
    for _s in [SBasePlugin]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RenderLayoutPlugin, name, value)
    __swig_getmethods__ = {}
    for _s in [SBasePlugin]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, RenderLayoutPlugin, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(RenderLayoutPlugin self, string uri, string prefix, RenderPkgNamespaces groupsns) -> RenderLayoutPlugin
        __init__(RenderLayoutPlugin self, RenderLayoutPlugin orig) -> RenderLayoutPlugin


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            RenderLayoutPlugin(RenderLayoutPlugin  orig)

        Copy constructor. Creates a copy of this SBase object.

        ______________________________________________________________________
        Method variant with the following signature:

            RenderLayoutPlugin(string &uri, string &prefix,
        RenderPkgNamespaces groupsns)

        Constructor

        """
        this = _libsbml.new_RenderLayoutPlugin(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_RenderLayoutPlugin
    __del__ = lambda self: None

    def clone(self):
        """
        clone(RenderLayoutPlugin self) -> RenderLayoutPlugin


        Creates and returns a deep copy of this RenderLayoutPlugin  object.

        Returns a (deep) copy of this RenderLayoutPlugin object

        """
        return _libsbml.RenderLayoutPlugin_clone(self)


    def getListOfLocalRenderInformation(self, *args):
        """
        getListOfLocalRenderInformation(RenderLayoutPlugin self) -> ListOfLocalRenderInformation
        getListOfLocalRenderInformation(RenderLayoutPlugin self) -> ListOfLocalRenderInformation


        Returns a pointer to the list object that contains local render
        information.

        """
        return _libsbml.RenderLayoutPlugin_getListOfLocalRenderInformation(self, *args)


    def getNumLocalRenderInformationObjects(self):
        """
        getNumLocalRenderInformationObjects(RenderLayoutPlugin self) -> unsigned int


        Returns the number of local render information objects.

        """
        return _libsbml.RenderLayoutPlugin_getNumLocalRenderInformationObjects(self)


    def getRenderInformation(self, *args):
        """
        getRenderInformation(RenderLayoutPlugin self, unsigned int index) -> LocalRenderInformation
        getRenderInformation(RenderLayoutPlugin self, unsigned int index) -> LocalRenderInformation
        getRenderInformation(RenderLayoutPlugin self, string id) -> LocalRenderInformation
        getRenderInformation(RenderLayoutPlugin self, string id) -> LocalRenderInformation


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getRenderInformation(long index)

        Returns a  pointer to the local render information object with the
        given index. If the index is invalid, 'None' is returned.

        ______________________________________________________________________
        Method variant with the following signature:

            getRenderInformation(string id)

        Returns a  pointer to the local render information object with the
        given id. If no object with the given 'id' exists, 'None' is returned.

        """
        return _libsbml.RenderLayoutPlugin_getRenderInformation(self, *args)


    def addLocalRenderInformation(self, pLRI):
        """
        addLocalRenderInformation(RenderLayoutPlugin self, LocalRenderInformation pLRI)


        Adds a copy of the given local render information object to the list
        of local render information objects. If an object with the same id
        exists, it is replaced.

        """
        return _libsbml.RenderLayoutPlugin_addLocalRenderInformation(self, pLRI)


    def createLocalRenderInformation(self):
        """
        createLocalRenderInformation(RenderLayoutPlugin self) -> LocalRenderInformation


        Creates a new local render information object and adds it to the list.
        The created object does not have a id and it is the responsibility of
        the calling code to ensure that it gets one. For constraints on the
        id, please consult the render information document.

        """
        return _libsbml.RenderLayoutPlugin_createLocalRenderInformation(self)


    def removeLocalRenderInformation(self, *args):
        """
        removeLocalRenderInformation(RenderLayoutPlugin self, unsigned int index) -> LocalRenderInformation
        removeLocalRenderInformation(RenderLayoutPlugin self, string id) -> LocalRenderInformation


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeLocalRenderInformation(long index)

        Removed the render information with the given index from the list. The
        removed object is returned. It is the responsibility of the calling
        code to delete the object. If the index is not valid, 'None' is
        returned.

        ______________________________________________________________________
        Method variant with the following signature:

            removeLocalRenderInformation(string id)

        Removed the render information with the given 'id' from the list. The
        removed object is returned. It is the responsibility of the calling
        code to delete the object. If an object with the given 'id' does not
        exist, 'None' is returned.

        """
        return _libsbml.RenderLayoutPlugin_removeLocalRenderInformation(self, *args)


    def createObject(self, stream):
        """
        createObject(RenderLayoutPlugin self, XMLInputStream stream) -> SBase


        Internal implementation method.

        """
        return _libsbml.RenderLayoutPlugin_createObject(self, stream)


    def writeAttributes(self, stream):
        """
        writeAttributes(RenderLayoutPlugin self, XMLOutputStream stream)


        Internal implementation method.

        """
        return _libsbml.RenderLayoutPlugin_writeAttributes(self, stream)


    def hasRequiredElements(self):
        """
        hasRequiredElements(RenderLayoutPlugin self) -> bool


        Internal implementation method.

        """
        return _libsbml.RenderLayoutPlugin_hasRequiredElements(self)


    def connectToParent(self, sbase):
        """
        connectToParent(RenderLayoutPlugin self, SBase sbase)


        Internal implementation method.

        """
        return _libsbml.RenderLayoutPlugin_connectToParent(self, sbase)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(RenderLayoutPlugin self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.RenderLayoutPlugin_enablePackageInternal(self, pkgURI, pkgPrefix, flag)

RenderLayoutPlugin_swigregister = _libsbml.RenderLayoutPlugin_swigregister
RenderLayoutPlugin_swigregister(RenderLayoutPlugin)

class RenderGraphicalObjectPlugin(SBasePlugin):
    """

    [SBML 'render' package]

    The Render extension of the layout GraphicalObject class.

    The Render package extends the GraphicalObject object from the Layout
    package  with the addition of the objectRole attribute, which
    specifies with which Style the object should be rendered.

    """

    __swig_setmethods__ = {}
    for _s in [SBasePlugin]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RenderGraphicalObjectPlugin, name, value)
    __swig_getmethods__ = {}
    for _s in [SBasePlugin]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, RenderGraphicalObjectPlugin, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(RenderGraphicalObjectPlugin self, string uri, string prefix, RenderPkgNamespaces groupsns) -> RenderGraphicalObjectPlugin
        __init__(RenderGraphicalObjectPlugin self, RenderGraphicalObjectPlugin orig) -> RenderGraphicalObjectPlugin


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            RenderGraphicalObjectPlugin(RenderGraphicalObjectPlugin
        orig)

        Copy constructor. Creates a copy of this SBase object.

        ______________________________________________________________________
        Method variant with the following signature:

            RenderGraphicalObjectPlugin(string &uri, string &prefix,
        RenderPkgNamespaces groupsns)

        Constructor

        """
        this = _libsbml.new_RenderGraphicalObjectPlugin(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_RenderGraphicalObjectPlugin
    __del__ = lambda self: None

    def clone(self):
        """
        clone(RenderGraphicalObjectPlugin self) -> RenderGraphicalObjectPlugin


        Creates and returns a deep copy of this RenderGraphicalObjectPlugin
        object.

        Returns a (deep) copy of this RenderGraphicalObjectPlugin object

        """
        return _libsbml.RenderGraphicalObjectPlugin_clone(self)


    def addExpectedAttributes(self, attributes):
        """
        addExpectedAttributes(RenderGraphicalObjectPlugin self, ExpectedAttributes & attributes)


        Internal implementation method.

        """
        return _libsbml.RenderGraphicalObjectPlugin_addExpectedAttributes(self, attributes)


    def readAttributes(self, attributes, expectedAttributes):
        """
        readAttributes(RenderGraphicalObjectPlugin self, XMLAttributes attributes, ExpectedAttributes const & expectedAttributes)


        Internal implementation method.

        """
        return _libsbml.RenderGraphicalObjectPlugin_readAttributes(self, attributes, expectedAttributes)


    def writeAttributes(self, stream):
        """
        writeAttributes(RenderGraphicalObjectPlugin self, XMLOutputStream stream)


        Internal implementation method.

        """
        return _libsbml.RenderGraphicalObjectPlugin_writeAttributes(self, stream)


    def getObjectRole(self):
        """
        getObjectRole(RenderGraphicalObjectPlugin self) -> string


        Returns the object role string for the object.

        """
        return _libsbml.RenderGraphicalObjectPlugin_getObjectRole(self)


    def setObjectRole(self, role):
        """
        setObjectRole(RenderGraphicalObjectPlugin self, string role)


        Sets the object role string for the object.

        """
        return _libsbml.RenderGraphicalObjectPlugin_setObjectRole(self, role)


    def isSetObjectRole(self):
        """
        isSetObjectRole(RenderGraphicalObjectPlugin self) -> bool


        Returns whether the object role has been set or not.

        """
        return _libsbml.RenderGraphicalObjectPlugin_isSetObjectRole(self)

RenderGraphicalObjectPlugin_swigregister = _libsbml.RenderGraphicalObjectPlugin_swigregister
RenderGraphicalObjectPlugin_swigregister(RenderGraphicalObjectPlugin)

class Transformation(SBase):
    """

    [SBML 'render' package]

    Implementation of a 3D transformation matrix.

    The Transformation class represents a 3D transformation which normally
    is a 4x4 matrix.  Since the last row is always 0 0 0 1 for affine
    transformations, we leave out those values and store the matrix as an
    array of 4x3 columns

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Transformation, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Transformation, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(Transformation self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> Transformation
        __init__(Transformation self, unsigned int level, unsigned int version) -> Transformation
        __init__(Transformation self, unsigned int level) -> Transformation
        __init__(Transformation self) -> Transformation
        __init__(Transformation self, RenderPkgNamespaces renderns) -> Transformation
        __init__(Transformation self, Transformation orig) -> Transformation


        Internal implementation method.

        """
        this = _libsbml.new_Transformation(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(Transformation self) -> Transformation


        Creates and returns a deep copy of this Transformation object.

        Returns a (deep) copy of this Transformation object.

        """
        return _libsbml.Transformation_clone(self)

    __swig_destroy__ = _libsbml.delete_Transformation
    __del__ = lambda self: None

    def getTransform(self, outArray):
        """
        getTransform(Transformation self, double * outArray)


        Returns the value of the 'transform' attribute of this Transformation.

        Parameter 'outArray' is double* array that will be used to return the
        value of the 'transform' attribute of this Transformation.

        Note: the value of the 'transform' attribute of this Transformation is
        returned in the argument array.

        """
        return _libsbml.Transformation_getTransform(self, outArray)


    def getName(self):
        """
        getName(Transformation self) -> string


        Returns the value of the 'name' attribute of this Transformation.

        Returns the value of the 'name' attribute of this Transformation as a
        string.

        """
        return _libsbml.Transformation_getName(self)


    def getMatrix(self):
        """
        getMatrix(Transformation self) -> double const *


        Returns the value of the 'transform' attribute of this Transformation.
        which is an array of double values of length 12.

        Returns a pointer to the array of numbers for the transformation.

        """
        return _libsbml.Transformation_getMatrix(self)


    def getIdentityMatrix():
        """
        getIdentityMatrix() -> double const *


        Returns a 3D identity matrix. The matrix contains 12 double values.

        """
        return _libsbml.Transformation_getIdentityMatrix()

    getIdentityMatrix = staticmethod(getIdentityMatrix)

    def isSetTransform(self):
        """
        isSetTransform(Transformation self) -> bool


        Predicate returning 'True' if this Transformation's 'transform'
        attribute is set.

        Returns 'True' if this Transformation's 'transform' attribute has been
        set, otherwise 'False' is returned.

        """
        return _libsbml.Transformation_isSetTransform(self)


    def isSetName(self):
        """
        isSetName(Transformation self) -> bool


        Predicate returning 'True' if this Transformation's 'name' attribute
        is set.

        Returns 'True' if this Transformation's 'name' attribute has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.Transformation_isSetName(self)


    def isSetMatrix(self):
        """
        isSetMatrix(Transformation self) -> bool


        Returns 'True' if the matrix has been set or 'False' otherwise. The
        matrix is considered as set if none of the values in the matrix is
        NaN.

        Returns 'True' or 'False' depending on whether a NaN was found.

        """
        return _libsbml.Transformation_isSetMatrix(self)


    def setTransform(self, inArray):
        """
        setTransform(Transformation self, double * inArray) -> int


        Sets the value of the 'transform' attribute of this Transformation.

        Parameter 'inArray' is double* array value of the 'transform'
        attribute to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Transformation_setTransform(self, inArray)


    def setName(self, name):
        """
        setName(Transformation self, string name) -> int


        Sets the value of the 'name' attribute of this Transformation.

        Parameter 'name' is string& value of the 'name' attribute to be set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        Calling this function with 'name' = 'None' or an empty string is
        equivalent to calling unsetName().

        """
        return _libsbml.Transformation_setName(self, name)


    def setMatrix(self, m):
        """
        setMatrix(Transformation self, double const [12] m)


        Sets the matrix to the values given in the array.

        Parameter 'm' is array with new values to be set for this
        Transformation object.

        """
        return _libsbml.Transformation_setMatrix(self, m)


    def unsetTransform(self):
        """
        unsetTransform(Transformation self) -> int


        Unsets the value of the 'transform' attribute of this Transformation.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Transformation_unsetTransform(self)


    def unsetName(self):
        """
        unsetName(Transformation self) -> int


        Unsets the value of the 'name' attribute of this Transformation.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Transformation_unsetName(self)


    def unsetMatrix(self):
        """
        unsetMatrix(Transformation self) -> int


        Unsets the value of the 'transform' attribute of this Transformation.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Transformation_unsetMatrix(self)


    def isImage(self):
        """
        isImage(Transformation self) -> bool


        Predicate returning 'True' if this abstract Transformation is of type
        Image

        Returns 'True' if this abstract Transformation is of type Image,
        'False' otherwise

        """
        return _libsbml.Transformation_isImage(self)


    def isEllipse(self):
        """
        isEllipse(Transformation self) -> bool


        Predicate returning 'True' if this abstract Transformation is of type
        Ellipse

        Returns 'True' if this abstract Transformation is of type Ellipse,
        'False' otherwise

        """
        return _libsbml.Transformation_isEllipse(self)


    def isRectangle(self):
        """
        isRectangle(Transformation self) -> bool


        Predicate returning 'True' if this abstract Transformation is of type
        Rectangle

        Returns 'True' if this abstract Transformation is of type Rectangle,
        'False' otherwise

        """
        return _libsbml.Transformation_isRectangle(self)


    def isPolygon(self):
        """
        isPolygon(Transformation self) -> bool


        Predicate returning 'True' if this abstract Transformation is of type
        Polygon

        Returns 'True' if this abstract Transformation is of type Polygon,
        'False' otherwise

        """
        return _libsbml.Transformation_isPolygon(self)


    def isRenderGroup(self):
        """
        isRenderGroup(Transformation self) -> bool


        Predicate returning 'True' if this abstract Transformation is of type
        RenderGroup

        Returns 'True' if this abstract Transformation is of type RenderGroup,
        'False' otherwise

        """
        return _libsbml.Transformation_isRenderGroup(self)


    def isLineEnding(self):
        """
        isLineEnding(Transformation self) -> bool


        Predicate returning 'True' if this abstract Transformation is of type
        LineEnding

        Returns 'True' if this abstract Transformation is of type LineEnding,
        'False' otherwise

        """
        return _libsbml.Transformation_isLineEnding(self)


    def isText(self):
        """
        isText(Transformation self) -> bool


        Predicate returning 'True' if this abstract Transformation is of type
        Text

        Returns 'True' if this abstract Transformation is of type Text,
        'False' otherwise

        """
        return _libsbml.Transformation_isText(self)


    def isRenderCurve(self):
        """
        isRenderCurve(Transformation self) -> bool


        Predicate returning 'True' if this abstract Transformation is of type
        RenderCurve

        Returns 'True' if this abstract Transformation is of type RenderCurve,
        'False' otherwise

        """
        return _libsbml.Transformation_isRenderCurve(self)


    def getElementName(self):
        """
        getElementName(Transformation self) -> string


        Returns the XML element name of this Transformation object.

        For Transformation, the XML element name is always ''transformation'.'

        Returns the name of this element, i.e. ''transformation'.'

        """
        return _libsbml.Transformation_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(Transformation self) -> int


        Returns the libSBML type code for this Transformation object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object:
        SBML_RENDER_TRANSFORMATION.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.Transformation_getTypeCode(self)

Transformation_swigregister = _libsbml.Transformation_swigregister
Transformation_swigregister(Transformation)

def Transformation_getIdentityMatrix():
    """
    Transformation_getIdentityMatrix() -> double const *


    Returns a 3D identity matrix. The matrix contains 12 double values.

    """
    return _libsbml.Transformation_getIdentityMatrix()

class Transformation2D(Transformation):
    """

    [SBML 'render' package]

    Implementation of a 2D transformation matrix.

    The Transformation2D class represents a 2D transformation. it is
    derived from Transformation and inherits all the attributes of a 3D
    transformation. In addition is provides new methods to explicitly get
    and set 2D transformation properties.  A 2D transformation normally
    consists of a 3x3 matrix, but since the last row is always 0 0 1, this
    is reduced to a 6 value array.

    Using one of the new 2D specific functions to set the matrix always
    updates the 3D matrix automatically and vice versa, so the 2D data and
    the 3D data inherited from Transformation should always be consistent.

    """

    __swig_setmethods__ = {}
    for _s in [Transformation]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Transformation2D, name, value)
    __swig_getmethods__ = {}
    for _s in [Transformation]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Transformation2D, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def clone(self):
        """
        clone(Transformation2D self) -> Transformation2D


        Creates and returns a deep copy of this Transformation2D object.

        Returns a (deep) copy of this Transformation2D object.

        """
        return _libsbml.Transformation2D_clone(self)

    __swig_destroy__ = _libsbml.delete_Transformation2D
    __del__ = lambda self: None

    def isImage(self):
        """
        isImage(Transformation2D self) -> bool


        Predicate returning 'True' if this abstract Transformation2D is of
        type Image

        Returns 'True' if this abstract Transformation2D is of type Image,
        'False' otherwise

        """
        return _libsbml.Transformation2D_isImage(self)


    def isEllipse(self):
        """
        isEllipse(Transformation2D self) -> bool


        Predicate returning 'True' if this abstract Transformation2D is of
        type Ellipse

        Returns 'True' if this abstract Transformation2D is of type Ellipse,
        'False' otherwise

        """
        return _libsbml.Transformation2D_isEllipse(self)


    def isRectangle(self):
        """
        isRectangle(Transformation2D self) -> bool


        Predicate returning 'True' if this abstract Transformation2D is of
        type Rectangle

        Returns 'True' if this abstract Transformation2D is of type Rectangle,
        'False' otherwise

        """
        return _libsbml.Transformation2D_isRectangle(self)


    def isPolygon(self):
        """
        isPolygon(Transformation2D self) -> bool


        Predicate returning 'True' if this abstract Transformation2D is of
        type Polygon

        Returns 'True' if this abstract Transformation2D is of type Polygon,
        'False' otherwise

        """
        return _libsbml.Transformation2D_isPolygon(self)


    def isRenderGroup(self):
        """
        isRenderGroup(Transformation2D self) -> bool


        Predicate returning 'True' if this abstract Transformation2D is of
        type RenderGroup

        Returns 'True' if this abstract Transformation2D is of type
        RenderGroup, 'False' otherwise

        """
        return _libsbml.Transformation2D_isRenderGroup(self)


    def isLineEnding(self):
        """
        isLineEnding(Transformation2D self) -> bool


        Predicate returning 'True' if this abstract Transformation2D is of
        type LineEnding

        Returns 'True' if this abstract Transformation2D is of type
        LineEnding, 'False' otherwise

        """
        return _libsbml.Transformation2D_isLineEnding(self)


    def isText(self):
        """
        isText(Transformation2D self) -> bool


        Predicate returning 'True' if this abstract Transformation2D is of
        type Text

        Returns 'True' if this abstract Transformation2D is of type Text,
        'False' otherwise

        """
        return _libsbml.Transformation2D_isText(self)


    def isRenderCurve(self):
        """
        isRenderCurve(Transformation2D self) -> bool


        Predicate returning 'True' if this abstract Transformation2D is of
        type RenderCurve

        Returns 'True' if this abstract Transformation2D is of type
        RenderCurve, 'False' otherwise

        """
        return _libsbml.Transformation2D_isRenderCurve(self)


    def getIdentityMatrix2D():
        """
        getIdentityMatrix2D() -> double const *


        Returns a 2D identity matrix. The matrix contains 6 double values.

        """
        return _libsbml.Transformation2D_getIdentityMatrix2D()

    getIdentityMatrix2D = staticmethod(getIdentityMatrix2D)

    def setMatrix2D(self, m):
        """
        setMatrix2D(Transformation2D self, double const [6] m)


        Sets the 2D matrix to the values given in the array. The 3D matrix is
        updated accordingly.

        Parameter 'm' is array with new values to be set for this
        Transformation object.

        """
        return _libsbml.Transformation2D_setMatrix2D(self, m)


    def setMatrix(self, m):
        """
        setMatrix(Transformation2D self, double const [12] m)


        Sets the 2D matrix to the values given in the array. The 2D matrix is
        updated accordingly.

        Parameter 'm' is array with new values to be set for this
        Transformation object.

        """
        return _libsbml.Transformation2D_setMatrix(self, m)


    def getMatrix2D(self):
        """
        getMatrix2D(Transformation2D self) -> double const *


        Returns the 2D matrix which is an array of double values of length 6.

        Returns a pointer to the array of numbers for the 2D transformation.

        """
        return _libsbml.Transformation2D_getMatrix2D(self)


    def getElementName(self):
        """
        getElementName(Transformation2D self) -> string


        Returns the XML element name of this Transformation2D object.

        For Transformation2D, the XML element name is always
        ''transformation2D'.'

        Returns the name of this element, i.e. ''transformation2D'.'

        """
        return _libsbml.Transformation2D_getElementName(self)


    def setElementName(self, name):
        """
        setElementName(Transformation2D self, string name)


        Internal implementation method.

        """
        return _libsbml.Transformation2D_setElementName(self, name)


    def getTypeCode(self):
        """
        getTypeCode(Transformation2D self) -> int


        Returns the libSBML type code for this Transformation2D object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object:
        SBML_RENDER_TRANSFORMATION2D.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.Transformation2D_getTypeCode(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(Transformation2D self) -> bool


        Predicate returning 'True' if all the required attributes for this
        Transformation2D object have been set.

        Returns 'True' to indicate that all the required attributes of this
        Transformation2D have been set, otherwise 'False' is returned.

        """
        return _libsbml.Transformation2D_hasRequiredAttributes(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(Transformation2D self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.Transformation2D_enablePackageInternal(self, pkgURI, pkgPrefix, flag)


    def toXML(self):
        """
        toXML(Transformation2D self) -> XMLNode


        Creates an XMLNode object from this Transformation2D object.

        Returns the XMLNode with the XML representation for the
        Transformation2D object.

        This method is purely virtual and has to be overwritten by derived
        classes.

        """
        return _libsbml.Transformation2D_toXML(self)

Transformation2D_swigregister = _libsbml.Transformation2D_swigregister
Transformation2D_swigregister(Transformation2D)

def Transformation2D_getIdentityMatrix2D():
    """
    Transformation2D_getIdentityMatrix2D() -> double const *


    Returns a 2D identity matrix. The matrix contains 6 double values.

    """
    return _libsbml.Transformation2D_getIdentityMatrix2D()

class GraphicalPrimitive1D(Transformation2D):
    """

    [SBML 'render' package]

    Base class for graphical primitives implementing 1D attributes.

    The GraphicalPrimitive1D class implements attributes and methods
    necessary for 1D objects like lines. The attributes that are
    implemented are a stroke color, a stroke width and a stroke dasharray
    for dashed line drawing.  Additionally, this class adds an id
    attribute with which all graphical primitives can be referenced.

    The GraphicalPrimitive1D class is derived from Transformation2D and
    inherits all its methods and attributes.

    """

    __swig_setmethods__ = {}
    for _s in [Transformation2D]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GraphicalPrimitive1D, name, value)
    __swig_getmethods__ = {}
    for _s in [Transformation2D]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, GraphicalPrimitive1D, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def clone(self):
        """
        clone(GraphicalPrimitive1D self) -> GraphicalPrimitive1D


        Creates and returns a deep copy of this GraphicalPrimitive1D object.

        Returns a (deep) copy of this GraphicalPrimitive1D object.

        """
        return _libsbml.GraphicalPrimitive1D_clone(self)

    __swig_destroy__ = _libsbml.delete_GraphicalPrimitive1D
    __del__ = lambda self: None

    def getId(self):
        """
        getId(GraphicalPrimitive1D self) -> string


        Returns the value of the 'id' attribute of this GraphicalPrimitive1D.

        Returns the value of the 'id' attribute of this GraphicalPrimitive1D
        as a string.

        """
        return _libsbml.GraphicalPrimitive1D_getId(self)


    def getStroke(self):
        """
        getStroke(GraphicalPrimitive1D self) -> string


        Returns the value of the 'stroke' attribute of this
        GraphicalPrimitive1D.

        Returns the value of the 'stroke' attribute of this
        GraphicalPrimitive1D as a string.

        """
        return _libsbml.GraphicalPrimitive1D_getStroke(self)


    def getStrokeWidth(self):
        """
        getStrokeWidth(GraphicalPrimitive1D self) -> double


        Returns the value of the 'stroke-width' attribute of this
        GraphicalPrimitive1D.

        Returns the value of the 'stroke-width' attribute of this
        GraphicalPrimitive1D as a double.

        """
        return _libsbml.GraphicalPrimitive1D_getStrokeWidth(self)


    def getStrokeDashArray(self):
        """
        getStrokeDashArray(GraphicalPrimitive1D self) -> std::vector< unsigned int > const &


        Returns the value of the 'stroke-dasharray' attribute of this
        GraphicalPrimitive1D.

        Note: the value of the 'stroke-dasharray' attribute of this
        GraphicalPrimitive1D is returned in the argument array.

        """
        return _libsbml.GraphicalPrimitive1D_getStrokeDashArray(self)


    def isSetId(self):
        """
        isSetId(GraphicalPrimitive1D self) -> bool


        Predicate returning 'True' if this GraphicalPrimitive1D's 'id'
        attribute is set.

        Returns 'True' if this GraphicalPrimitive1D's 'id' attribute has been
        set, otherwise 'False' is returned.

        """
        return _libsbml.GraphicalPrimitive1D_isSetId(self)


    def isSetStroke(self):
        """
        isSetStroke(GraphicalPrimitive1D self) -> bool


        Predicate returning 'True' if this GraphicalPrimitive1D's 'stroke'
        attribute is set.

        Returns 'True' if this GraphicalPrimitive1D's 'stroke' attribute has
        been set, otherwise 'False' is returned.

        """
        return _libsbml.GraphicalPrimitive1D_isSetStroke(self)


    def isSetStrokeWidth(self):
        """
        isSetStrokeWidth(GraphicalPrimitive1D self) -> bool


        Predicate returning 'True' if this GraphicalPrimitive1D's 'stroke-
        width' attribute is set.

        Returns 'True' if this GraphicalPrimitive1D's 'stroke-width' attribute
        has been set, otherwise 'False' is returned.

        """
        return _libsbml.GraphicalPrimitive1D_isSetStrokeWidth(self)


    def isSetStrokeDashArray(self):
        """
        isSetStrokeDashArray(GraphicalPrimitive1D self) -> bool


        Predicate returning 'True' if this GraphicalPrimitive1D's 'stroke-
        dasharray' attribute is set.

        Returns 'True' if this GraphicalPrimitive1D's 'stroke-dasharray'
        attribute has been set, otherwise 'False' is returned.

        """
        return _libsbml.GraphicalPrimitive1D_isSetStrokeDashArray(self)


    def isSetDashArray(self):
        """
        isSetDashArray(GraphicalPrimitive1D self) -> bool


        Returns 'True' if the dash array has been set or 'False' otherwise.
        The array is considered set if it is not empty and if the first entry
        is not 'NaN.'

        Returns 'True' if the stroke-dasharray is set, 'False' otherwise.

        """
        return _libsbml.GraphicalPrimitive1D_isSetDashArray(self)


    def setId(self, id):
        """
        setId(GraphicalPrimitive1D self, string id) -> int


        Sets the value of the 'id' attribute of this GraphicalPrimitive1D.

        Parameter 'id' is string& value of the 'id' attribute to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        Calling this function with 'id' = 'None' or an empty string is
        equivalent to calling unsetId().

        """
        return _libsbml.GraphicalPrimitive1D_setId(self, id)


    def setStroke(self, stroke):
        """
        setStroke(GraphicalPrimitive1D self, string stroke) -> int


        Sets the value of the 'stroke' attribute of this GraphicalPrimitive1D.

        Parameter 'stroke' is string& value of the 'stroke' attribute to be
        set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        Calling this function with 'stroke' = 'None' or an empty string is
        equivalent to calling unsetStroke().

        """
        return _libsbml.GraphicalPrimitive1D_setStroke(self, stroke)


    def setStrokeWidth(self, strokeWidth):
        """
        setStrokeWidth(GraphicalPrimitive1D self, double strokeWidth) -> int


        Sets the value of the 'stroke-width' attribute of this
        GraphicalPrimitive1D.

        Parameter 'strokeWidth' is double value of the 'stroke-width'
        attribute to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.GraphicalPrimitive1D_setStrokeWidth(self, strokeWidth)


    def setStrokeDashArray(self, array):
        """
        setStrokeDashArray(GraphicalPrimitive1D self, std::vector< unsigned int > const & array) -> int


        Sets the value of the 'stroke-dasharray' attribute of this
        GraphicalPrimitive1D.

        Parameter 'array' is value of the 'stroke-dasharray' attribute to be
        set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.GraphicalPrimitive1D_setStrokeDashArray(self, array)


    def getNumDashes(self):
        """
        getNumDashes(GraphicalPrimitive1D self) -> unsigned int


        Returns the number of defined dashes in the 'stroke-dasharray'
        attribute.

        Returns the number of dashes in the 'stroke-dasharray' attribute.

        """
        return _libsbml.GraphicalPrimitive1D_getNumDashes(self)


    def getDashByIndex(self, index):
        """
        getDashByIndex(GraphicalPrimitive1D self, unsigned int index) -> unsigned int


        Returns the dash at the given index of the 'stroke-dasharray'
        attribute.

        Parameter 'index' is the index of the dash length to return from the
        'stroke-dasharray' attribute.

        Returns the value of the dash length from the 'stroke-dasharray'
        attribute at the given index, or -1 (cast to a long integer) if no
        such index exists.

        """
        return _libsbml.GraphicalPrimitive1D_getDashByIndex(self, index)


    def addDash(self, dash):
        """
        addDash(GraphicalPrimitive1D self, unsigned int dash)


        Adds a new length of a dash to the 'stroke-dasharray' attribute.

        Parameter 'dash' is the integer length of the dash to add to the end
        of the 'stroke-dasharray' attribute.

        """
        return _libsbml.GraphicalPrimitive1D_addDash(self, dash)


    def clearDashes(self):
        """
        clearDashes(GraphicalPrimitive1D self)


        Unsets the value of the 'stroke-dasharray' attribute of this
        GraphicalPrimitive1D.

        """
        return _libsbml.GraphicalPrimitive1D_clearDashes(self)


    def setDashByIndex(self, index, dash):
        """
        setDashByIndex(GraphicalPrimitive1D self, unsigned int index, unsigned int dash)


        Sets the integer value of the dash at the given position.

        Parameter 'index' is the index of the dash length to replace in the
        'stroke-dasharray' attribute.  The function will fail silently  if no
        such index exists.

        Parameter 'dash' is the integer length to set the indexed dash to.

        """
        return _libsbml.GraphicalPrimitive1D_setDashByIndex(self, index, dash)


    def insertDash(self, index, dash):
        """
        insertDash(GraphicalPrimitive1D self, unsigned int index, unsigned int dash)


        Inserts the given integer value for the dash length at the  given
        position.

        Parameter 'index' is the index of the dash length at which the new
        dash is to be inserted in the 'stroke-dasharray' attribute.  The
        function will fail silently if no such index exists.

        Parameter 'dash' is the integer length to set the inserted dash to.

        """
        return _libsbml.GraphicalPrimitive1D_insertDash(self, index, dash)


    def removeDash(self, index):
        """
        removeDash(GraphicalPrimitive1D self, unsigned int index)


        Removes the dash length at the given index.

        Parameter 'index' is the index of the dash length to remove from the
        'stroke-dasharray' attribute. The function will fail silently if no
        such index exists.

        """
        return _libsbml.GraphicalPrimitive1D_removeDash(self, index)


    def unsetId(self):
        """
        unsetId(GraphicalPrimitive1D self) -> int


        Unsets the value of the 'id' attribute of this GraphicalPrimitive1D.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.GraphicalPrimitive1D_unsetId(self)


    def unsetStroke(self):
        """
        unsetStroke(GraphicalPrimitive1D self) -> int


        Unsets the value of the 'stroke' attribute of this
        GraphicalPrimitive1D.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.GraphicalPrimitive1D_unsetStroke(self)


    def unsetStrokeWidth(self):
        """
        unsetStrokeWidth(GraphicalPrimitive1D self) -> int


        Unsets the value of the 'stroke-width' attribute of this
        GraphicalPrimitive1D.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.GraphicalPrimitive1D_unsetStrokeWidth(self)


    def unsetStrokeDashArray(self):
        """
        unsetStrokeDashArray(GraphicalPrimitive1D self) -> int


        Unsets the value of the 'stroke-dasharray' attribute of this
        GraphicalPrimitive1D.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.GraphicalPrimitive1D_unsetStrokeDashArray(self)


    def isEllipse(self):
        """
        isEllipse(GraphicalPrimitive1D self) -> bool


        Predicate returning 'True' if this abstract GraphicalPrimitive1D is of
        type Ellipse

        Returns 'True' if this abstract GraphicalPrimitive1D is of type
        Ellipse, 'False' otherwise

        """
        return _libsbml.GraphicalPrimitive1D_isEllipse(self)


    def isRectangle(self):
        """
        isRectangle(GraphicalPrimitive1D self) -> bool


        Predicate returning 'True' if this abstract GraphicalPrimitive1D is of
        type Rectangle

        Returns 'True' if this abstract GraphicalPrimitive1D is of type
        Rectangle, 'False' otherwise

        """
        return _libsbml.GraphicalPrimitive1D_isRectangle(self)


    def isPolygon(self):
        """
        isPolygon(GraphicalPrimitive1D self) -> bool


        Predicate returning 'True' if this abstract GraphicalPrimitive1D is of
        type Polygon

        Returns 'True' if this abstract GraphicalPrimitive1D is of type
        Polygon, 'False' otherwise

        """
        return _libsbml.GraphicalPrimitive1D_isPolygon(self)


    def isRenderGroup(self):
        """
        isRenderGroup(GraphicalPrimitive1D self) -> bool


        Predicate returning 'True' if this abstract GraphicalPrimitive1D is of
        type RenderGroup

        Returns 'True' if this abstract GraphicalPrimitive1D is of type
        RenderGroup, 'False' otherwise

        """
        return _libsbml.GraphicalPrimitive1D_isRenderGroup(self)


    def isLineEnding(self):
        """
        isLineEnding(GraphicalPrimitive1D self) -> bool


        Predicate returning 'True' if this abstract GraphicalPrimitive1D is of
        type LineEnding

        Returns 'True' if this abstract GraphicalPrimitive1D is of type
        LineEnding, 'False' otherwise

        """
        return _libsbml.GraphicalPrimitive1D_isLineEnding(self)


    def isText(self):
        """
        isText(GraphicalPrimitive1D self) -> bool


        Predicate returning 'True' if this abstract GraphicalPrimitive1D is of
        type Text

        Returns 'True' if this abstract GraphicalPrimitive1D is of type Text,
        'False' otherwise

        """
        return _libsbml.GraphicalPrimitive1D_isText(self)


    def isRenderCurve(self):
        """
        isRenderCurve(GraphicalPrimitive1D self) -> bool


        Predicate returning 'True' if this abstract GraphicalPrimitive1D is of
        type RenderCurve

        Returns 'True' if this abstract GraphicalPrimitive1D is of type Text,
        'False' otherwise

        """
        return _libsbml.GraphicalPrimitive1D_isRenderCurve(self)


    def getTypeCode(self):
        """
        getTypeCode(GraphicalPrimitive1D self) -> int


        Returns the libSBML type code for this GraphicalPrimitive1D object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object:
        SBML_RENDER_GRAPHICALPRIMITIVE1D.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.GraphicalPrimitive1D_getTypeCode(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(GraphicalPrimitive1D self) -> bool


        Predicate returning 'True' if all the required attributes for this
        GraphicalPrimitive1D object have been set.

        Returns 'True' to indicate that all the required attributes of this
        GraphicalPrimitive1D have been set, otherwise 'False' is returned.

        """
        return _libsbml.GraphicalPrimitive1D_hasRequiredAttributes(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(GraphicalPrimitive1D self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.GraphicalPrimitive1D_enablePackageInternal(self, pkgURI, pkgPrefix, flag)


    def toXML(self):
        """
        toXML(GraphicalPrimitive1D self) -> XMLNode


        Creates an XMLNode object from this GraphicalPrimitive1D object.

        Returns the XMLNode with the XML representation for the
        GraphicalPrimitive1D object.

        This method is purely virtual and has to be implemented by subclasses.

        """
        return _libsbml.GraphicalPrimitive1D_toXML(self)

GraphicalPrimitive1D_swigregister = _libsbml.GraphicalPrimitive1D_swigregister
GraphicalPrimitive1D_swigregister(GraphicalPrimitive1D)

class GraphicalPrimitive2D(GraphicalPrimitive1D):
    """

    [SBML 'render' package]

    Base class for graphical primitives implementing 2D attributes.

    The GraphicalPrimitive2D class implements attributes and methods
    necessary for 2D objects like rectangles, polygons or ellipses. The
    attributes that are implemented are a fill color and a fill rule that
    specifies how the fill color is applied.

    The GraphicalPrimitive2D class is derived from GraphicalPrimitive1D
    and inherits all its methods and attributes.

    """

    __swig_setmethods__ = {}
    for _s in [GraphicalPrimitive1D]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GraphicalPrimitive2D, name, value)
    __swig_getmethods__ = {}
    for _s in [GraphicalPrimitive1D]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, GraphicalPrimitive2D, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    UNSET = _libsbml.GraphicalPrimitive2D_UNSET
    NONZERO = _libsbml.GraphicalPrimitive2D_NONZERO
    EVENODD = _libsbml.GraphicalPrimitive2D_EVENODD
    INHERIT = _libsbml.GraphicalPrimitive2D_INHERIT
    INVALID = _libsbml.GraphicalPrimitive2D_INVALID

    def clone(self):
        """
        clone(GraphicalPrimitive2D self) -> GraphicalPrimitive2D


        Creates and returns a deep copy of this GraphicalPrimitive2D object.

        Returns a (deep) copy of this GraphicalPrimitive2D object.

        """
        return _libsbml.GraphicalPrimitive2D_clone(self)

    __swig_destroy__ = _libsbml.delete_GraphicalPrimitive2D
    __del__ = lambda self: None

    def getFill(self):
        """
        getFill(GraphicalPrimitive2D self) -> string


        Returns the value of the 'fill' attribute of this
        GraphicalPrimitive2D.

        Returns the value of the 'fill' attribute of this GraphicalPrimitive2D
        as a string.

        """
        return _libsbml.GraphicalPrimitive2D_getFill(self)


    def getFillColor(self):
        """
        getFillColor(GraphicalPrimitive2D self) -> string


        Returns the value of the 'fill' attribute of this
        GraphicalPrimitive2D.

        Returns the value of the 'fill' attribute of this GraphicalPrimitive2D
        as a string.

        """
        return _libsbml.GraphicalPrimitive2D_getFillColor(self)


    def getFillRule(self):
        """
        getFillRule(GraphicalPrimitive2D self) -> int


        Returns the value of the 'fill-rule' attribute of this
        GraphicalPrimitive2D.

        The attribute 'fill-rule' is used to define how polygons should be
        filled. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'fill-rule':

        * ''nonzero':' This value determines the 'insideness' of a point in
        the shape by drawing a ray from that point to infinity in any
        direction  and then examining the places where a segment of the shape
        crosses the ray.  Starting with a count of zero, add one each time a
        path segment crosses  the ray from left to right and subtract one each
        time a path segment crosses  the ray from right to left. After
        counting the crossings, if the result is  zero then the point is
        outside the path. Otherwise, it is inside.

        * ''evenodd':'  This value determines the 'insideness' of a point in
        the shape by drawing a ray from that point to infinity in any
        direction  and counting the number of path segments from the given
        shape that the ray crosses. If this number is odd, the point is
        inside; if even, the point is  outside.

        * ''inherit':' This value declares the 'insideness' of a point  in the
        shape by declaring that the property takes the same computed value  as
        the property for the element's parent. The inherited value, which is
        normally only used as a fallback value, can be clarified by setting
        'inherit' explicitly.  NOTE:  This value is NOT in the Level 3
        Version 1 Render specification, but was left out due to an oversight:
        the value has long been part of the codebase.  It is provided here as
        a convenience.  Elements with a fill-rule set to 'inherit' actually
        behave identicaly to elements without a fill-rule attribute at all,
        since this attribute always takes the value of a parent element if not
        defined explicitly.

        Returns the value of the 'fill-rule' attribute of this
        GraphicalPrimitive2D as an int value. The possible values returned by
        this method are:

        * FILL_RULE_UNSET

        * FILL_RULE_NONZERO

        * FILL_RULE_EVENODD

        * FILL_RULE_INHERIT

        * FILL_RULE_INVALID

        """
        return _libsbml.GraphicalPrimitive2D_getFillRule(self)


    def getFillRuleAsString(self):
        """
        getFillRuleAsString(GraphicalPrimitive2D self) -> string


        Returns the value of the 'fill-rule' attribute of this
        GraphicalPrimitive2D.

        The attribute 'fill-rule' is used to define how polygons should be
        filled. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'fill-rule':

        * ''nonzero':' This value determines the 'insideness' of a point in
        the shape by drawing a ray from that point to infinity in any
        direction  and then examining the places where a segment of the shape
        crosses the ray.  Starting with a count of zero, add one each time a
        path segment crosses  the ray from left to right and subtract one each
        time a path segment crosses  the ray from right to left. After
        counting the crossings, if the result is  zero then the point is
        outside the path. Otherwise, it is inside.

        * ''evenodd':'  This value determines the 'insideness' of a point in
        the shape by drawing a ray from that point to infinity in any
        direction  and counting the number of path segments from the given
        shape that the ray crosses. If this number is odd, the point is
        inside; if even, the point is  outside.

        * ''inherit':' This value declares the 'insideness' of a point  in the
        shape by declaring that the property takes the same computed value  as
        the property for the element's parent. The inherited value, which is
        normally only used as a fallback value, can be clarified by setting
        'inherit' explicitly.  NOTE:  This value is NOT in the Level 3
        Version 1 Render specification, but was left out due to an oversight:
        the value has long been part of the codebase.  It is provided here as
        a convenience.  Elements with a fill-rule set to 'inherit' actually
        behave identicaly to elements without a fill-rule attribute at all,
        since this attribute always takes the value of a parent element if not
        defined explicitly.

        Returns the value of the 'fill-rule' attribute of this
        GraphicalPrimitive2D as a string. The possible values returned by this
        method are:

        * ''unset''

        * ''nonzero''

        * ''evenodd''

        * ''inherit''

        * ''(Unknown' FillRule value)'

        """
        return _libsbml.GraphicalPrimitive2D_getFillRuleAsString(self)


    def isSetFill(self):
        """
        isSetFill(GraphicalPrimitive2D self) -> bool


        Predicate returning 'True' if this GraphicalPrimitive2D's 'fill'
        attribute is set.

        Returns 'True' if this GraphicalPrimitive2D's 'fill' attribute has
        been set, otherwise 'False' is returned.

        """
        return _libsbml.GraphicalPrimitive2D_isSetFill(self)


    def isSetFillColor(self):
        """
        isSetFillColor(GraphicalPrimitive2D self) -> bool


        Returns 'True' if the fill attribute is set or 'False' otherwise. The
        fill attribute is considered set if the string is not empty.

        Returns 'True' if the fill color is set.

        """
        return _libsbml.GraphicalPrimitive2D_isSetFillColor(self)


    def isSetFillRule(self):
        """
        isSetFillRule(GraphicalPrimitive2D self) -> bool


        Predicate returning 'True' if this GraphicalPrimitive2D's 'fill-rule'
        attribute is set.

        The attribute 'fill-rule' is used to define how polygons should be
        filled. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'fill-rule':

        * ''nonzero':' This value determines the 'insideness' of a point in
        the shape by drawing a ray from that point to infinity in any
        direction  and then examining the places where a segment of the shape
        crosses the ray.  Starting with a count of zero, add one each time a
        path segment crosses  the ray from left to right and subtract one each
        time a path segment crosses  the ray from right to left. After
        counting the crossings, if the result is  zero then the point is
        outside the path. Otherwise, it is inside.

        * ''evenodd':'  This value determines the 'insideness' of a point in
        the shape by drawing a ray from that point to infinity in any
        direction  and counting the number of path segments from the given
        shape that the ray crosses. If this number is odd, the point is
        inside; if even, the point is  outside.

        * ''inherit':' This value declares the 'insideness' of a point  in the
        shape by declaring that the property takes the same computed value  as
        the property for the element's parent. The inherited value, which is
        normally only used as a fallback value, can be clarified by setting
        'inherit' explicitly.  NOTE:  This value is NOT in the Level 3
        Version 1 Render specification, but was left out due to an oversight:
        the value has long been part of the codebase.  It is provided here as
        a convenience.  Elements with a fill-rule set to 'inherit' actually
        behave identicaly to elements without a fill-rule attribute at all,
        since this attribute always takes the value of a parent element if not
        defined explicitly.

        Returns 'True' if this GraphicalPrimitive2D's 'fill-rule' attribute
        has been set, otherwise 'False' is returned.

        """
        return _libsbml.GraphicalPrimitive2D_isSetFillRule(self)


    def setFill(self, fill):
        """
        setFill(GraphicalPrimitive2D self, string fill) -> int


        Sets the value of the 'fill' attribute of this GraphicalPrimitive2D.

        Parameter 'fill' is string& value of the 'fill' attribute to be set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        Calling this function with 'fill' = 'None' or an empty string is
        equivalent to calling unsetFill().

        """
        return _libsbml.GraphicalPrimitive2D_setFill(self, fill)


    def setFillColor(self, color):
        """
        setFillColor(GraphicalPrimitive2D self, string color)


        Set fill color to the id of a color definition, the id of a gradient
        definition or a color value string.

        Parameter 'color' is the id of a color deifnition or a gradient or a
        color value string.

        """
        return _libsbml.GraphicalPrimitive2D_setFillColor(self, color)


    def setFillRule(self, *args):
        """
        setFillRule(GraphicalPrimitive2D self, GraphicalPrimitive2D::FILL_RULE rule)
        setFillRule(GraphicalPrimitive2D self, FillRule_t const fillRule) -> int
        setFillRule(GraphicalPrimitive2D self, string fillRule) -> int


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            setFillRule(string fillRule)

        Sets the value of the 'fill-rule' attribute of this
        GraphicalPrimitive2D.

        The attribute 'fill-rule' is used to define how polygons should be
        filled. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'fill-rule':

        * ''nonzero':' This value determines the 'insideness' of a point in
        the shape by drawing a ray from that point to infinity in any
        direction  and then examining the places where a segment of the shape
        crosses the ray.  Starting with a count of zero, add one each time a
        path segment crosses  the ray from left to right and subtract one each
        time a path segment crosses  the ray from right to left. After
        counting the crossings, if the result is  zero then the point is
        outside the path. Otherwise, it is inside.

        * ''evenodd':'  This value determines the 'insideness' of a point in
        the shape by drawing a ray from that point to infinity in any
        direction  and counting the number of path segments from the given
        shape that the ray crosses. If this number is odd, the point is
        inside; if even, the point is  outside.

        * ''inherit':' This value declares the 'insideness' of a point  in the
        shape by declaring that the property takes the same computed value  as
        the property for the element's parent. The inherited value, which is
        normally only used as a fallback value, can be clarified by setting
        'inherit' explicitly.  NOTE:  This value is NOT in the Level 3
        Version 1 Render specification, but was left out due to an oversight:
        the value has long been part of the codebase.  It is provided here as
        a convenience.  Elements with a fill-rule set to 'inherit' actually
        behave identicaly to elements without a fill-rule attribute at all,
        since this attribute always takes the value of a parent element if not
        defined explicitly.

        Parameter 'fillRule' is string& of the 'fill-rule' attribute to be
        set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        ______________________________________________________________________
        Method variant with the following signature:

            setFillRule(FILL_RULE rule)

        Sets the value of the 'fill-rule' attribute of this
        GraphicalPrimitive2D.

        The attribute 'fill-rule' is used to define how polygons should be
        filled. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'fill-rule':

        * ''nonzero':' This value determines the 'insideness' of a point in
        the shape by drawing a ray from that point to infinity in any
        direction  and then examining the places where a segment of the shape
        crosses the ray.  Starting with a count of zero, add one each time a
        path segment crosses  the ray from left to right and subtract one each
        time a path segment crosses  the ray from right to left. After
        counting the crossings, if the result is  zero then the point is
        outside the path. Otherwise, it is inside.

        * ''evenodd':'  This value determines the 'insideness' of a point in
        the shape by drawing a ray from that point to infinity in any
        direction  and counting the number of path segments from the given
        shape that the ray crosses. If this number is odd, the point is
        inside; if even, the point is  outside.

        * ''inherit':' This value declares the 'insideness' of a point  in the
        shape by declaring that the property takes the same computed value  as
        the property for the element's parent. The inherited value, which is
        normally only used as a fallback value, can be clarified by setting
        'inherit' explicitly.  NOTE:  This value is NOT in the Level 3
        Version 1 Render specification, but was left out due to an oversight:
        the value has long been part of the codebase.  It is provided here as
        a convenience.  Elements with a fill-rule set to 'inherit' actually
        behave identicaly to elements without a fill-rule attribute at all,
        since this attribute always takes the value of a parent element if not
        defined explicitly.

        Parameter 'rule' is int value of the 'fill-rule' attribute to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        ______________________________________________________________________
        Method variant with the following signature:

            setFillRule( FillRule_t fillRule)

        Sets the value of the 'fill-rule' attribute of this
        GraphicalPrimitive2D.

        The attribute 'fill-rule' is used to define how polygons should be
        filled. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'fill-rule':

        * ''nonzero':' This value determines the 'insideness' of a point in
        the shape by drawing a ray from that point to infinity in any
        direction  and then examining the places where a segment of the shape
        crosses the ray.  Starting with a count of zero, add one each time a
        path segment crosses  the ray from left to right and subtract one each
        time a path segment crosses  the ray from right to left. After
        counting the crossings, if the result is  zero then the point is
        outside the path. Otherwise, it is inside.

        * ''evenodd':'  This value determines the 'insideness' of a point in
        the shape by drawing a ray from that point to infinity in any
        direction  and counting the number of path segments from the given
        shape that the ray crosses. If this number is odd, the point is
        inside; if even, the point is  outside.

        * ''inherit':' This value declares the 'insideness' of a point  in the
        shape by declaring that the property takes the same computed value  as
        the property for the element's parent. The inherited value, which is
        normally only used as a fallback value, can be clarified by setting
        'inherit' explicitly.  NOTE:  This value is NOT in the Level 3
        Version 1 Render specification, but was left out due to an oversight:
        the value has long been part of the codebase.  It is provided here as
        a convenience.  Elements with a fill-rule set to 'inherit' actually
        behave identicaly to elements without a fill-rule attribute at all,
        since this attribute always takes the value of a parent element if not
        defined explicitly.

        Parameter 'fillRule' is int value of the 'fill-rule' attribute to be
        set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.GraphicalPrimitive2D_setFillRule(self, *args)


    def unsetFill(self):
        """
        unsetFill(GraphicalPrimitive2D self) -> int


        Unsets the value of the 'fill' attribute of this GraphicalPrimitive2D.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.GraphicalPrimitive2D_unsetFill(self)


    def unsetFillRule(self):
        """
        unsetFillRule(GraphicalPrimitive2D self) -> int


        Unsets the value of the 'fill-rule' attribute of this
        GraphicalPrimitive2D.

        The attribute 'fill-rule' is used to define how polygons should be
        filled. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'fill-rule':

        * ''nonzero':' This value determines the 'insideness' of a point in
        the shape by drawing a ray from that point to infinity in any
        direction  and then examining the places where a segment of the shape
        crosses the ray.  Starting with a count of zero, add one each time a
        path segment crosses  the ray from left to right and subtract one each
        time a path segment crosses  the ray from right to left. After
        counting the crossings, if the result is  zero then the point is
        outside the path. Otherwise, it is inside.

        * ''evenodd':'  This value determines the 'insideness' of a point in
        the shape by drawing a ray from that point to infinity in any
        direction  and counting the number of path segments from the given
        shape that the ray crosses. If this number is odd, the point is
        inside; if even, the point is  outside.

        * ''inherit':' This value declares the 'insideness' of a point  in the
        shape by declaring that the property takes the same computed value  as
        the property for the element's parent. The inherited value, which is
        normally only used as a fallback value, can be clarified by setting
        'inherit' explicitly.  NOTE:  This value is NOT in the Level 3
        Version 1 Render specification, but was left out due to an oversight:
        the value has long been part of the codebase.  It is provided here as
        a convenience.  Elements with a fill-rule set to 'inherit' actually
        behave identicaly to elements without a fill-rule attribute at all,
        since this attribute always takes the value of a parent element if not
        defined explicitly.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.GraphicalPrimitive2D_unsetFillRule(self)


    def isEllipse(self):
        """
        isEllipse(GraphicalPrimitive2D self) -> bool


        Predicate returning 'True' if this abstract GraphicalPrimitive2D is of
        type Ellipse

        Returns 'True' if this abstract GraphicalPrimitive2D is of type
        Ellipse, 'False' otherwise

        """
        return _libsbml.GraphicalPrimitive2D_isEllipse(self)


    def isRectangle(self):
        """
        isRectangle(GraphicalPrimitive2D self) -> bool


        Predicate returning 'True' if this abstract GraphicalPrimitive2D is of
        type Rectangle

        Returns 'True' if this abstract GraphicalPrimitive2D is of type
        Rectangle, 'False' otherwise

        """
        return _libsbml.GraphicalPrimitive2D_isRectangle(self)


    def isPolygon(self):
        """
        isPolygon(GraphicalPrimitive2D self) -> bool


        Predicate returning 'True' if this abstract GraphicalPrimitive2D is of
        type Polygon

        Returns 'True' if this abstract GraphicalPrimitive2D is of type
        Polygon, 'False' otherwise

        """
        return _libsbml.GraphicalPrimitive2D_isPolygon(self)


    def isRenderGroup(self):
        """
        isRenderGroup(GraphicalPrimitive2D self) -> bool


        Predicate returning 'True' if this abstract GraphicalPrimitive2D is of
        type RenderGroup

        Returns 'True' if this abstract GraphicalPrimitive2D is of type
        RenderGroup, 'False' otherwise

        """
        return _libsbml.GraphicalPrimitive2D_isRenderGroup(self)


    def isLineEnding(self):
        """
        isLineEnding(GraphicalPrimitive2D self) -> bool


        Predicate returning 'True' if this abstract GraphicalPrimitive2D is of
        type LineEnding

        Returns 'True' if this abstract GraphicalPrimitive2D is of type
        LineEnding, 'False' otherwise

        """
        return _libsbml.GraphicalPrimitive2D_isLineEnding(self)


    def getElementName(self):
        """
        getElementName(GraphicalPrimitive2D self) -> string


        Returns the XML element name of this GraphicalPrimitive2D object.

        For GraphicalPrimitive2D, the XML element name is always
        ''graphicalPrimitive2D'.'

        Returns the name of this element, i.e. ''graphicalPrimitive2D'.'

        """
        return _libsbml.GraphicalPrimitive2D_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(GraphicalPrimitive2D self) -> int


        Returns the libSBML type code for this GraphicalPrimitive2D object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object:
        SBML_RENDER_GRAPHICALPRIMITIVE2D.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.GraphicalPrimitive2D_getTypeCode(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(GraphicalPrimitive2D self) -> bool


        Predicate returning 'True' if all the required attributes for this
        GraphicalPrimitive2D object have been set.

        Returns 'True' to indicate that all the required attributes of this
        GraphicalPrimitive2D have been set, otherwise 'False' is returned.

        """
        return _libsbml.GraphicalPrimitive2D_hasRequiredAttributes(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(GraphicalPrimitive2D self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.GraphicalPrimitive2D_enablePackageInternal(self, pkgURI, pkgPrefix, flag)

GraphicalPrimitive2D_swigregister = _libsbml.GraphicalPrimitive2D_swigregister
GraphicalPrimitive2D_swigregister(GraphicalPrimitive2D)

class RenderInformationBase(SBase):
    """

    [SBML 'render' package]

    Abstract base class for local and global rendering information.

    In the SBML Level 3 Render package, local and global render
    information representations share many attributes. These are
    implemented in this abstract base class.  GlobalRenderInformation and
    LocalRenderInformation are the classes that are derived from this base
    class.

    All render information objects have the following things in common:

    * a set of color definitions

    * a set of gradient definitions

    * a set of line endings

    In addition to those, they share attributes for background color and
    some meta information as to which program created the render
    information etc.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RenderInformationBase, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, RenderInformationBase, name)
    __repr__ = _swig_repr

    def clone(self):
        """
        clone(RenderInformationBase self) -> RenderInformationBase


        Creates and returns a deep copy of this RenderInformationBase object.

        Returns a (deep) copy of this RenderInformationBase object.

        """
        return _libsbml.RenderInformationBase_clone(self)

    __swig_destroy__ = _libsbml.delete_RenderInformationBase
    __del__ = lambda self: None

    def parseXML(self, pNode):
        """
        parseXML(RenderInformationBase self, XMLNode pNode)


        Parses the XML information in the given node and sets the attributes.
        This method should never be called by the user. It is only used to
        read render  information from annotations.

        Parameter 'pNode' is the XMLNode object reference that describes the
        RenderinformationBase object to be instantiated.

        """
        return _libsbml.RenderInformationBase_parseXML(self, pNode)


    def __init__(self, *args):
        """
        __init__(RenderInformationBase self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> RenderInformationBase
        __init__(RenderInformationBase self, unsigned int level, unsigned int version) -> RenderInformationBase
        __init__(RenderInformationBase self, unsigned int level) -> RenderInformationBase
        __init__(RenderInformationBase self) -> RenderInformationBase
        __init__(RenderInformationBase self, RenderPkgNamespaces renderns) -> RenderInformationBase
        __init__(RenderInformationBase self, RenderInformationBase orig) -> RenderInformationBase
        __init__(RenderInformationBase self, RenderPkgNamespaces renderns, string id) -> RenderInformationBase


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            RenderInformationBase(long level =
        RenderExtension.getDefaultLevel(), long version =
        RenderExtension.getDefaultVersion(), long pkgVersion =
        RenderExtension.getDefaultPackageVersion())

        Creates a new RenderInformationBase using the given SBML Level,
        Version and "render" package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        RenderInformationBase.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this RenderInformationBase.

        Parameter 'pkgVersion' is a long integer, the SBML Render Version to
        assign to this RenderInformationBase.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            RenderInformationBase(RenderPkgNamespaces renderns, string
        id)

        Constructor which creates a RenderInformationBase object empty color
        definition, gradient definition and line endings set. For the object
        to be valid a valid background color value.

        WARNING:

        This constructor is deprecated. The new libSBML API uses constructors
        that either take the SBML Level and Version, or take an SBMLNamespaces
        object.

        ______________________________________________________________________
        Method variant with the following signature:

            RenderInformationBase(RenderPkgNamespaces renderns)

        Creates a new RenderInformationBase using the given
        RenderPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'renderns' is the RenderPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        ______________________________________________________________________
        Method variant with the following signature:

            RenderInformationBase(RenderInformationBase orig)

        Copy constructor for RenderInformationBase.

        Parameter 'orig' is the RenderInformationBase instance to copy.

        """
        this = _libsbml.new_RenderInformationBase(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def getId(self):
        """
        getId(RenderInformationBase self) -> string


        Returns the value of the 'id' attribute of this RenderInformationBase.

        Returns the value of the 'id' attribute of this RenderInformationBase
        as a string.

        """
        return _libsbml.RenderInformationBase_getId(self)


    def getName(self):
        """
        getName(RenderInformationBase self) -> string


        Returns the value of the 'name' attribute of this
        RenderInformationBase.

        Returns the value of the 'name' attribute of this
        RenderInformationBase as a string.

        """
        return _libsbml.RenderInformationBase_getName(self)


    def getProgramName(self):
        """
        getProgramName(RenderInformationBase self) -> string


        Returns the value of the 'programName' attribute of this
        RenderInformationBase.

        Returns the value of the 'programName' attribute of this
        RenderInformationBase as a string.

        """
        return _libsbml.RenderInformationBase_getProgramName(self)


    def getProgramVersion(self):
        """
        getProgramVersion(RenderInformationBase self) -> string


        Returns the value of the 'programVersion' attribute of this
        RenderInformationBase.

        Returns the value of the 'programVersion' attribute of this
        RenderInformationBase as a string.

        """
        return _libsbml.RenderInformationBase_getProgramVersion(self)


    def getReferenceRenderInformationId(self):
        """
        getReferenceRenderInformationId(RenderInformationBase self) -> string


        Returns the value of the 'referenceRenderInformation' attribute of
        this RenderInformationBase. Returns the id of the referenced render
        information object. Renderinformation objects can reference other
        render information objects and information that is not found in the
        current render information is then expected to be in the referenced
        render information object.

        Global render information objects can only reference other global
        render information objects, local render information objects can
        reference other local render information objects from the same list of
        local render information or other global render information.

        Returns the value of the 'referenceRenderInformation' attribute of
        this RenderInformationBase as a string.

        """
        return _libsbml.RenderInformationBase_getReferenceRenderInformationId(self)


    def getReferenceRenderInformation(self):
        """
        getReferenceRenderInformation(RenderInformationBase self) -> string


        Returns the value of the 'referenceRenderInformation' attribute of
        this RenderInformationBase.

        Returns the value of the 'referenceRenderInformation' attribute of
        this RenderInformationBase as a string.

        """
        return _libsbml.RenderInformationBase_getReferenceRenderInformation(self)


    def getBackgroundColor(self):
        """
        getBackgroundColor(RenderInformationBase self) -> string


        Returns the value of the 'backgroundColor' attribute of this
        RenderInformationBase.

        Returns the value of the 'backgroundColor' attribute of this
        RenderInformationBase as a string.

        """
        return _libsbml.RenderInformationBase_getBackgroundColor(self)


    def isSetId(self):
        """
        isSetId(RenderInformationBase self) -> bool


        Predicate returning 'True' if this RenderInformationBase's 'id'
        attribute is set.

        Returns 'True' if this RenderInformationBase's 'id' attribute has been
        set, otherwise 'False' is returned.

        """
        return _libsbml.RenderInformationBase_isSetId(self)


    def isSetName(self):
        """
        isSetName(RenderInformationBase self) -> bool


        Predicate returning 'True' if this RenderInformationBase's 'name'
        attribute is set.

        Returns 'True' if this RenderInformationBase's 'name' attribute has
        been set, otherwise 'False' is returned.

        """
        return _libsbml.RenderInformationBase_isSetName(self)


    def isSetProgramName(self):
        """
        isSetProgramName(RenderInformationBase self) -> bool


        Predicate returning 'True' if this RenderInformationBase's
        'programName' attribute is set.

        Returns 'True' if this RenderInformationBase's 'programName' attribute
        has been set, otherwise 'False' is returned.

        """
        return _libsbml.RenderInformationBase_isSetProgramName(self)


    def isSetProgramVersion(self):
        """
        isSetProgramVersion(RenderInformationBase self) -> bool


        Predicate returning 'True' if this RenderInformationBase's
        'programVersion' attribute is set.

        Returns 'True' if this RenderInformationBase's 'programVersion'
        attribute has been set, otherwise 'False' is returned.

        """
        return _libsbml.RenderInformationBase_isSetProgramVersion(self)


    def isSetReferenceRenderInformation(self):
        """
        isSetReferenceRenderInformation(RenderInformationBase self) -> bool


        Predicate returning 'True' if this RenderInformationBase's
        'referenceRenderInformation' attribute is set.

        Returns 'True' if this RenderInformationBase's
        'referenceRenderInformation' attribute has been set, otherwise 'False'
        is returned.

        """
        return _libsbml.RenderInformationBase_isSetReferenceRenderInformation(self)


    def isSetBackgroundColor(self):
        """
        isSetBackgroundColor(RenderInformationBase self) -> bool


        Predicate returning 'True' if this RenderInformationBase's
        'backgroundColor' attribute is set.

        Returns 'True' if this RenderInformationBase's 'backgroundColor'
        attribute has been set, otherwise 'False' is returned.

        """
        return _libsbml.RenderInformationBase_isSetBackgroundColor(self)


    def setId(self, id):
        """
        setId(RenderInformationBase self, string id) -> int


        Sets the value of the 'id' attribute of this RenderInformationBase.

        Parameter 'id' is string& value of the 'id' attribute to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        Calling this function with 'id' = 'None' or an empty string is
        equivalent to calling unsetId().

        """
        return _libsbml.RenderInformationBase_setId(self, id)


    def setName(self, name):
        """
        setName(RenderInformationBase self, string name) -> int


        Sets the value of the 'name' attribute of this RenderInformationBase.

        Parameter 'name' is string& value of the 'name' attribute to be set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        Calling this function with 'name' = 'None' or an empty string is
        equivalent to calling unsetName().

        """
        return _libsbml.RenderInformationBase_setName(self, name)


    def setProgramName(self, programName):
        """
        setProgramName(RenderInformationBase self, string programName) -> int


        Sets the value of the 'programName' attribute of this
        RenderInformationBase.

        Parameter 'programName' is string& value of the 'programName'
        attribute to be set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        Calling this function with 'programName' = 'None' or an empty string
        is equivalent to calling unsetProgramName().

        """
        return _libsbml.RenderInformationBase_setProgramName(self, programName)


    def setProgramVersion(self, programVersion):
        """
        setProgramVersion(RenderInformationBase self, string programVersion) -> int


        Sets the value of the 'programVersion' attribute of this
        RenderInformationBase.

        Parameter 'programVersion' is string& value of the 'programVersion'
        attribute to be set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        Calling this function with 'programVersion' = 'None' or an empty
        string is equivalent to calling unsetProgramVersion().

        """
        return _libsbml.RenderInformationBase_setProgramVersion(self, programVersion)


    def setReferenceRenderInformationId(self, id):
        """
        setReferenceRenderInformationId(RenderInformationBase self, string id)


        Sets the value of the 'referenceRenderInformation' attribute of this
        RenderInformationBase. The user has to make sure that render
        information referencing  does not create loops.

        Parameter 'id' is the value for the 'referenceRenderInformation'
        attribute

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.RenderInformationBase_setReferenceRenderInformationId(self, id)


    def setReferenceRenderInformation(self, referenceRenderInformation):
        """
        setReferenceRenderInformation(RenderInformationBase self, string referenceRenderInformation) -> int


        Sets the value of the 'referenceRenderInformation' attribute of this
        RenderInformationBase.

        Parameter 'referenceRenderInformation' is string& value of the
        'referenceRenderInformation' attribute to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.RenderInformationBase_setReferenceRenderInformation(self, referenceRenderInformation)


    def setBackgroundColor(self, backgroundColor):
        """
        setBackgroundColor(RenderInformationBase self, string backgroundColor) -> int


        Sets the value of the 'backgroundColor' attribute of this
        RenderInformationBase.

        Parameter 'backgroundColor' is string& value of the 'backgroundColor'
        attribute to be set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        Calling this function with 'backgroundColor' = 'None' or an empty
        string is equivalent to calling unsetBackgroundColor().

        """
        return _libsbml.RenderInformationBase_setBackgroundColor(self, backgroundColor)


    def unsetId(self):
        """
        unsetId(RenderInformationBase self) -> int


        Unsets the value of the 'id' attribute of this RenderInformationBase.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.RenderInformationBase_unsetId(self)


    def unsetName(self):
        """
        unsetName(RenderInformationBase self) -> int


        Unsets the value of the 'name' attribute of this
        RenderInformationBase.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.RenderInformationBase_unsetName(self)


    def unsetProgramName(self):
        """
        unsetProgramName(RenderInformationBase self) -> int


        Unsets the value of the 'programName' attribute of this
        RenderInformationBase.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.RenderInformationBase_unsetProgramName(self)


    def unsetProgramVersion(self):
        """
        unsetProgramVersion(RenderInformationBase self) -> int


        Unsets the value of the 'programVersion' attribute of this
        RenderInformationBase.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.RenderInformationBase_unsetProgramVersion(self)


    def unsetReferenceRenderInformation(self):
        """
        unsetReferenceRenderInformation(RenderInformationBase self) -> int


        Unsets the value of the 'referenceRenderInformation' attribute of this
        RenderInformationBase.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.RenderInformationBase_unsetReferenceRenderInformation(self)


    def unsetBackgroundColor(self):
        """
        unsetBackgroundColor(RenderInformationBase self) -> int


        Unsets the value of the 'backgroundColor' attribute of this
        RenderInformationBase.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.RenderInformationBase_unsetBackgroundColor(self)


    def getListOfColorDefinitions(self, *args):
        """
        getListOfColorDefinitions(RenderInformationBase self) -> ListOfColorDefinitions
        getListOfColorDefinitions(RenderInformationBase self) -> ListOfColorDefinitions


        Returns the ListOfColorDefinitions from this RenderInformationBase.

        Returns the ListOfColorDefinitions from this RenderInformationBase.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addColorDefinition(), createColorDefinition(),
        getColorDefinition(), getColorDefinition(), getNumColorDefinitions(),
        removeColorDefinition(), removeColorDefinition().

        """
        return _libsbml.RenderInformationBase_getListOfColorDefinitions(self, *args)


    def getColorDefinition(self, *args):
        """
        getColorDefinition(RenderInformationBase self, unsigned int n) -> ColorDefinition
        getColorDefinition(RenderInformationBase self, unsigned int n) -> ColorDefinition
        getColorDefinition(RenderInformationBase self, string sid) -> ColorDefinition
        getColorDefinition(RenderInformationBase self, string sid) -> ColorDefinition


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getColorDefinition(long n)

        Get a ColorDefinition from the RenderInformationBase.

        Parameter 'n' is a long integer representing the index of the
        ColorDefinition to retrieve.

        Returns the nth ColorDefinition in the ListOfColorDefinitions within
        this RenderInformationBase or 'None' if no such ColorDefinition
        exists.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addColorDefinition(), createColorDefinition(),
        getColorDefinition(), getNumColorDefinitions(),
        removeColorDefinition(), removeColorDefinition().

        ______________________________________________________________________
        Method variant with the following signature:

            getColorDefinition(string sid)

        Get a ColorDefinition from the RenderInformationBase based on its
        identifier.

        Parameter 'sid' is a string representing the identifier of the
        ColorDefinition to retrieve.

        Returns the ColorDefinition in the ListOfColorDefinitions within this
        RenderInformationBase with the given 'sid' or 'None' if no such
        ColorDefinition exists.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addColorDefinition(), createColorDefinition(),
        getColorDefinition(), getNumColorDefinitions(),
        removeColorDefinition(), removeColorDefinition().

        """
        return _libsbml.RenderInformationBase_getColorDefinition(self, *args)


    def addColorDefinition(self, cd):
        """
        addColorDefinition(RenderInformationBase self, ColorDefinition cd) -> int


        Adds a copy of the given ColorDefinition to this
        RenderInformationBase.

        Parameter 'cd' is the ColorDefinition object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_PKG_VERSION_MISMATCH

        * LIBSBML_DUPLICATE_OBJECT_ID

        Note: This method should be used with some caution.  The fact that
        this method copies the object passed to it means that the caller will
        be left holding a physically different object instance than the one
        contained inside this object.  Changes made to the original object
        instance (such as resetting attribute values) will not affect the
        instance in this object.  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 other methods on this class
        (particularly a corresponding method whose name begins with the word
        create) for alternatives that do not lead to these issues.

        See also createColorDefinition(), getColorDefinition(),
        getColorDefinition(), getNumColorDefinitions(),
        removeColorDefinition(), removeColorDefinition().

        """
        return _libsbml.RenderInformationBase_addColorDefinition(self, cd)


    def getNumColorDefinitions(self):
        """
        getNumColorDefinitions(RenderInformationBase self) -> unsigned int


        Get the number of ColorDefinition objects in this
        RenderInformationBase.

        Returns the number of ColorDefinition objects in this
        RenderInformationBase.

        See also addColorDefinition(), createColorDefinition(),
        getColorDefinition(), getColorDefinition(), removeColorDefinition(),
        removeColorDefinition().

        """
        return _libsbml.RenderInformationBase_getNumColorDefinitions(self)


    def createColorDefinition(self):
        """
        createColorDefinition(RenderInformationBase self) -> ColorDefinition


        Creates a new ColorDefinition object, adds it to this
        RenderInformationBase object and returns the ColorDefinition object
        created.

        Returns a new ColorDefinition object instance.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addColorDefinition(), getColorDefinition(),
        getColorDefinition(), getNumColorDefinitions(),
        removeColorDefinition(), removeColorDefinition().

        """
        return _libsbml.RenderInformationBase_createColorDefinition(self)


    def removeColorDefinition(self, *args):
        """
        removeColorDefinition(RenderInformationBase self, unsigned int n) -> ColorDefinition
        removeColorDefinition(RenderInformationBase self, string sid) -> ColorDefinition


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeColorDefinition(long n)

        Removes the nth ColorDefinition from this RenderInformationBase and
        returns a pointer to it.

        Parameter 'n' is a long integer representing the index of the
        ColorDefinition to remove.

        Returns a pointer to the nth ColorDefinition in this
        RenderInformationBase.

        WARNING:

        The pointer that is returned by this function is owned by the caller,
        who is responsible for deleting it.  Any changes made to the element
        will not be reflected in any resulting SBML document unless the
        element is added to an SBML Document.  Even in this case, the
        element's deletion is still the responsibility of the caller with two
        exceptions: if it is used as the 'disownedItem' in the
        ListOf.appendAndOwn() or ListOf.insertAndOwn()  functions.  All other
        functions in libsbml add a copy of the element, and do not transfer
        ownership of the pointer.

        See also addColorDefinition(), createColorDefinition(),
        getColorDefinition(), getColorDefinition(), getNumColorDefinitions(),
        removeColorDefinition().

        ______________________________________________________________________
        Method variant with the following signature:

            removeColorDefinition(string sid)

        Removes the ColorDefinition from this RenderInformationBase based on
        its identifier and returns a pointer to it.

        Parameter 'sid' is a string representing the identifier of the
        ColorDefinition to remove.

        Returns the ColorDefinition in this RenderInformationBase based on the
        identifier or None if no such ColorDefinition exists.

        WARNING:

        The pointer that is returned by this function is owned by the caller,
        who is responsible for deleting it.  Any changes made to the element
        will not be reflected in any resulting SBML document unless the
        element is added to an SBML Document.  Even in this case, the
        element's deletion is still the responsibility of the caller with two
        exceptions: if it is used as the 'disownedItem' in the
        ListOf.appendAndOwn() or ListOf.insertAndOwn()  functions.  All other
        functions in libsbml add a copy of the element, and do not transfer
        ownership of the pointer.

        See also addColorDefinition(), createColorDefinition(),
        getColorDefinition(), getColorDefinition(), getNumColorDefinitions(),
        removeColorDefinition().

        """
        return _libsbml.RenderInformationBase_removeColorDefinition(self, *args)


    def getListOfGradientDefinitions(self, *args):
        """
        getListOfGradientDefinitions(RenderInformationBase self) -> ListOfGradientDefinitions
        getListOfGradientDefinitions(RenderInformationBase self) -> ListOfGradientDefinitions


        Returns the ListOfGradientDefinitions from this RenderInformationBase.

        Returns the ListOfGradientDefinitions from this RenderInformationBase.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addGradientDefinition(), createLinearGradientDefinition(),
        createRadialGradientDefinition(), getGradientDefinition(),
        getGradientDefinition(), getNumGradientDefinitions(),
        removeGraidentBase(), removeGradientDefinition().

        """
        return _libsbml.RenderInformationBase_getListOfGradientDefinitions(self, *args)


    def getGradientDefinition(self, *args):
        """
        getGradientDefinition(RenderInformationBase self, unsigned int n) -> GradientBase
        getGradientDefinition(RenderInformationBase self, unsigned int n) -> GradientBase
        getGradientDefinition(RenderInformationBase self, string sid) -> GradientBase
        getGradientDefinition(RenderInformationBase self, string sid) -> GradientBase


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getGradientDefinition(long n)

        Get a GradientBase from the RenderInformationBase.

        Parameter 'n' is a long integer representing the index of the
        GradientBase to retrieve.

        Returns the nth GradientBase in the ListOfGradientDefinitions within
        this RenderInformationBase or 'None' if no such GradientBase exists.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addGradientDefinition(), createLinearGradientDefinition(),
        createRadialGradientDefinition(), getGradientDefinition(),
        getNumGradientDefinitions(), removeGradientDefinition(),
        removeGradientDefinition().

        ______________________________________________________________________
        Method variant with the following signature:

            getGradientDefinition(string sid)

        Get a GradientBase from the RenderInformationBase based on its
        identifier.

        Parameter 'sid' is a string representing the identifier of the
        GradientBase to retrieve.

        Returns the GradientBase in the ListOfGradientDefinitions within this
        RenderInformationBase with the given 'sid' or 'None' if no such
        GradientBase exists.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addGradientDefinition(), createLinearGradientDefinition(),
        createRadialGradientDefinition(), getGradientDefinition(),
        getNumGradientDefinitions(), removeGradientDefinition(),
        removeGradientDefinition().

        """
        return _libsbml.RenderInformationBase_getGradientDefinition(self, *args)


    def addGradientDefinition(self, gb):
        """
        addGradientDefinition(RenderInformationBase self, GradientBase gb) -> int


        Adds a copy of the given GradientBase to this RenderInformationBase.

        Parameter 'gb' is the GradientBase object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_PKG_VERSION_MISMATCH

        * LIBSBML_DUPLICATE_OBJECT_ID

        Note: This method should be used with some caution.  The fact that
        this method copies the object passed to it means that the caller will
        be left holding a physically different object instance than the one
        contained inside this object.  Changes made to the original object
        instance (such as resetting attribute values) will not affect the
        instance in this object.  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 other methods on this class
        (particularly a corresponding method whose name begins with the word
        create) for alternatives that do not lead to these issues.

        See also createLinearGradientDefinition(),
        createRadialGradientDefinition(), getGradientDefinition(),
        getGradientDefinition(), getNumGradientDefinitions(),
        removeGradientDefinition(), removeGradientDefinition().

        """
        return _libsbml.RenderInformationBase_addGradientDefinition(self, gb)


    def getNumGradientDefinitions(self):
        """
        getNumGradientDefinitions(RenderInformationBase self) -> unsigned int


        Get the number of GradientBase objects in this RenderInformationBase.

        Returns the number of GradientBase objects in this
        RenderInformationBase.

        See also addGradientDefinition(), createLinearGradientDefinition(),
        createRadialGradientDefinition(), getGradientDefinition(),
        getGradientDefinition(), removeGradientDefinition(),
        removeGradientDefinition().

        """
        return _libsbml.RenderInformationBase_getNumGradientDefinitions(self)


    def createLinearGradientDefinition(self):
        """
        createLinearGradientDefinition(RenderInformationBase self) -> LinearGradient


        Creates a new LinearGradient object, adds it to this
        RenderInformationBase object and returns the LinearGradient object
        created.

        Returns a new LinearGradient object instance.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addGradientDefinition(), getGradientDefinition(),
        getGradientDefinition(), getNumGradientDefinitions(),
        removeGradientDefinition(), removeGradientDefinition().

        """
        return _libsbml.RenderInformationBase_createLinearGradientDefinition(self)


    def createRadialGradientDefinition(self):
        """
        createRadialGradientDefinition(RenderInformationBase self) -> RadialGradient


        Creates a new RadialGradient object, adds it to this
        RenderInformationBase object and returns the RadialGradient object
        created.

        Returns a new RadialGradient object instance.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addGradientDefinition(), getGradientDefinition(),
        getGradientDefinition(), getNumGradientDefinitions(),
        removeGradientDefinition(), removeGradientDefinition().

        """
        return _libsbml.RenderInformationBase_createRadialGradientDefinition(self)


    def removeGradientDefinition(self, *args):
        """
        removeGradientDefinition(RenderInformationBase self, unsigned int n) -> GradientBase
        removeGradientDefinition(RenderInformationBase self, string sid) -> GradientBase


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeGradientDefinition(long n)

        Removes the nth GradientBase from this RenderInformationBase and
        returns a pointer to it.

        Parameter 'n' is a long integer representing the index of the
        GradientBase to remove.

        Returns a pointer to the nth GradientBase in this
        RenderInformationBase.

        WARNING:

        The pointer that is returned by this function is owned by the caller,
        who is responsible for deleting it.  Any changes made to the element
        will not be reflected in any resulting SBML document unless the
        element is added to an SBML Document.  Even in this case, the
        element's deletion is still the responsibility of the caller with two
        exceptions: if it is used as the 'disownedItem' in the
        ListOf.appendAndOwn() or ListOf.insertAndOwn()  functions.  All other
        functions in libsbml add a copy of the element, and do not transfer
        ownership of the pointer.

        See also addGradientDefinition(), createLinearGradientDefinition(),
        createRadialGradientDefinition(), getGradientDefinition(),
        getGradientDefinition(), getNumGradientDefinitions(),
        removeGradientDefinition().

        ______________________________________________________________________
        Method variant with the following signature:

            removeGradientDefinition(string sid)

        Removes the GradientBase from this RenderInformationBase based on its
        identifier and returns a pointer to it.

        Parameter 'sid' is a string representing the identifier of the
        GradientBase to remove.

        Returns the GradientBase in this RenderInformationBase based on the
        identifier or None if no such GradientBase exists.

        WARNING:

        The pointer that is returned by this function is owned by the caller,
        who is responsible for deleting it.  Any changes made to the element
        will not be reflected in any resulting SBML document unless the
        element is added to an SBML Document.  Even in this case, the
        element's deletion is still the responsibility of the caller with two
        exceptions: if it is used as the 'disownedItem' in the
        ListOf.appendAndOwn() or ListOf.insertAndOwn()  functions.  All other
        functions in libsbml add a copy of the element, and do not transfer
        ownership of the pointer.

        See also addGradientDefinition(), createLinearGradientDefinition(),
        createRadialGradientDefinition(), getGradientDefinition(),
        getGradientDefinition(), getNumGradientDefinitions(),
        removeGradientDefinition().

        """
        return _libsbml.RenderInformationBase_removeGradientDefinition(self, *args)


    def getListOfLineEndings(self, *args):
        """
        getListOfLineEndings(RenderInformationBase self) -> ListOfLineEndings
        getListOfLineEndings(RenderInformationBase self) -> ListOfLineEndings


        Returns the ListOfLineEndings from this RenderInformationBase.

        Returns the ListOfLineEndings from this RenderInformationBase.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addLineEnding(), createLineEnding(), getLineEnding(),
        getLineEnding(), getNumLineEndings(), removeLineEnding(),
        removeLineEnding().

        """
        return _libsbml.RenderInformationBase_getListOfLineEndings(self, *args)


    def getLineEnding(self, *args):
        """
        getLineEnding(RenderInformationBase self, unsigned int n) -> LineEnding
        getLineEnding(RenderInformationBase self, unsigned int n) -> LineEnding
        getLineEnding(RenderInformationBase self, string sid) -> LineEnding
        getLineEnding(RenderInformationBase self, string sid) -> LineEnding


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getLineEnding(long n)

        Get a LineEnding from the RenderInformationBase.

        Parameter 'n' is a long integer representing the index of the
        LineEnding to retrieve.

        Returns the nth LineEnding in the ListOfLineEndings within this
        RenderInformationBase or 'None' if no such LineEnding exists.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addLineEnding(), createLineEnding(), getLineEnding(),
        getNumLineEndings(), removeLineEnding(), removeLineEnding().

        ______________________________________________________________________
        Method variant with the following signature:

            getLineEnding(string sid)

        Get a LineEnding from the RenderInformationBase based on its
        identifier.

        Parameter 'sid' is a string representing the identifier of the
        LineEnding to retrieve.

        Returns the LineEnding in the ListOfLineEndings within this
        RenderInformationBase with the given 'sid' or 'None' if no such
        LineEnding exists.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addLineEnding(), createLineEnding(), getLineEnding(),
        getNumLineEndings(), removeLineEnding(), removeLineEnding().

        """
        return _libsbml.RenderInformationBase_getLineEnding(self, *args)


    def addLineEnding(self, le):
        """
        addLineEnding(RenderInformationBase self, LineEnding le) -> int


        Adds a copy of the given LineEnding to this RenderInformationBase.

        Parameter 'le' is the LineEnding object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_PKG_VERSION_MISMATCH

        * LIBSBML_DUPLICATE_OBJECT_ID

        Note: This method should be used with some caution.  The fact that
        this method copies the object passed to it means that the caller will
        be left holding a physically different object instance than the one
        contained inside this object.  Changes made to the original object
        instance (such as resetting attribute values) will not affect the
        instance in this object.  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 other methods on this class
        (particularly a corresponding method whose name begins with the word
        create) for alternatives that do not lead to these issues.

        See also createLineEnding(), getLineEnding(), getLineEnding(),
        getNumLineEndings(), removeLineEnding(), removeLineEnding().

        """
        return _libsbml.RenderInformationBase_addLineEnding(self, le)


    def getNumLineEndings(self):
        """
        getNumLineEndings(RenderInformationBase self) -> unsigned int


        Get the number of LineEnding objects in this RenderInformationBase.

        Returns the number of LineEnding objects in this
        RenderInformationBase.

        See also addLineEnding(), createLineEnding(), getLineEnding(),
        getLineEnding(), removeLineEnding(), removeLineEnding().

        """
        return _libsbml.RenderInformationBase_getNumLineEndings(self)


    def createLineEnding(self):
        """
        createLineEnding(RenderInformationBase self) -> LineEnding


        Creates a new LineEnding object, adds it to this RenderInformationBase
        object and returns the LineEnding object created.

        Returns a new LineEnding object instance.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addLineEnding(), getLineEnding(), getLineEnding(),
        getNumLineEndings(), removeLineEnding(), removeLineEnding().

        """
        return _libsbml.RenderInformationBase_createLineEnding(self)


    def removeLineEnding(self, *args):
        """
        removeLineEnding(RenderInformationBase self, unsigned int n) -> LineEnding
        removeLineEnding(RenderInformationBase self, string sid) -> LineEnding


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeLineEnding(long n)

        Removes the nth LineEnding from this RenderInformationBase and returns
        a pointer to it.

        Parameter 'n' is a long integer representing the index of the
        LineEnding to remove.

        Returns a pointer to the nth LineEnding in this RenderInformationBase.

        WARNING:

        The pointer that is returned by this function is owned by the caller,
        who is responsible for deleting it.  Any changes made to the element
        will not be reflected in any resulting SBML document unless the
        element is added to an SBML Document.  Even in this case, the
        element's deletion is still the responsibility of the caller with two
        exceptions: if it is used as the 'disownedItem' in the
        ListOf.appendAndOwn() or ListOf.insertAndOwn()  functions.  All other
        functions in libsbml add a copy of the element, and do not transfer
        ownership of the pointer.

        See also addLineEnding(), createLineEnding(), getLineEnding(),
        getLineEnding(), getNumLineEndings(), removeLineEnding().

        ______________________________________________________________________
        Method variant with the following signature:

            removeLineEnding(string sid)

        Removes the LineEnding from this RenderInformationBase based on its
        identifier and returns a pointer to it.

        Parameter 'sid' is a string representing the identifier of the
        LineEnding to remove.

        Returns the LineEnding in this RenderInformationBase based on the
        identifier or None if no such LineEnding exists.

        WARNING:

        The pointer that is returned by this function is owned by the caller,
        who is responsible for deleting it.  Any changes made to the element
        will not be reflected in any resulting SBML document unless the
        element is added to an SBML Document.  Even in this case, the
        element's deletion is still the responsibility of the caller with two
        exceptions: if it is used as the 'disownedItem' in the
        ListOf.appendAndOwn() or ListOf.insertAndOwn()  functions.  All other
        functions in libsbml add a copy of the element, and do not transfer
        ownership of the pointer.

        See also addLineEnding(), createLineEnding(), getLineEnding(),
        getLineEnding(), getNumLineEndings(), removeLineEnding().

        """
        return _libsbml.RenderInformationBase_removeLineEnding(self, *args)


    def isGlobalRenderInformation(self):
        """
        isGlobalRenderInformation(RenderInformationBase self) -> bool


        Predicate returning 'True' if this abstract RenderInformationBase is
        of type GlobalRenderInformation

        Returns 'True' if this abstract RenderInformationBase is of type
        GlobalRenderInformation, 'False' otherwise

        """
        return _libsbml.RenderInformationBase_isGlobalRenderInformation(self)


    def isLocalRenderInformation(self):
        """
        isLocalRenderInformation(RenderInformationBase self) -> bool


        Predicate returning 'True' if this abstract RenderInformationBase is
        of type LocalRenderInformation

        Returns 'True' if this abstract RenderInformationBase is of type
        LocalRenderInformation, 'False' otherwise

        """
        return _libsbml.RenderInformationBase_isLocalRenderInformation(self)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(RenderInformationBase self, string oldid, string newid)


        Replaces all uses of a given 'SIdRef' type attribute value with
        another value.

        In SBML, object identifiers are of a data type called SId. In SBML
        Level 3, an explicit data type called SIdRef was introduced for
        attribute values that refer to SId values; in previous Levels of SBML,
        this data type did not exist and attributes were simply described to
        as 'referring to an identifier', but the effective data type was the
        same as SIdRef in Level 3.  These and other methods of libSBML refer
        to the type SIdRef for all Levels of SBML, even if the corresponding
        SBML specification did not explicitly name the data type.

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas in MathML content, comparing the referenced
        identifiers to the value of 'oldid'.  If any matches are found, the
        matching values are replaced with 'newid'.  The method does not
        descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.RenderInformationBase_renameSIdRefs(self, oldid, newid)


    def getTypeCode(self):
        """
        getTypeCode(RenderInformationBase self) -> int


        Returns the libSBML type code for this RenderInformationBase object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object:
        SBML_RENDER_RENDERINFORMATION_BASE.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.RenderInformationBase_getTypeCode(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(RenderInformationBase self) -> bool


        Predicate returning 'True' if all the required attributes for this
        RenderInformationBase object have been set.

        Returns 'True' to indicate that all the required attributes of this
        RenderInformationBase have been set, otherwise 'False' is returned.

        Note: The required attributes for the RenderInformationBase object
        are:

        * 'id'

        """
        return _libsbml.RenderInformationBase_hasRequiredAttributes(self)


    def connectToChild(self):
        """
        connectToChild(RenderInformationBase self)


        Internal implementation method.

        """
        return _libsbml.RenderInformationBase_connectToChild(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(RenderInformationBase self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.RenderInformationBase_enablePackageInternal(self, pkgURI, pkgPrefix, flag)


    def getElementBySId(self, id):
        """
        getElementBySId(RenderInformationBase self, string id) -> SBase


        Returns the first child element that has the given 'id' in the model-
        wide SId namespace, or 'None' if no such object is found.

        Parameter 'id' is a string representing the id attribute of the object
        to retrieve.

        Returns a pointer to the SBase element with the given 'id'. If no such
        object is found, this method returns 'None.'

        """
        return _libsbml.RenderInformationBase_getElementBySId(self, id)


    def getElementByMetaId(self, metaid):
        """
        getElementByMetaId(RenderInformationBase self, string metaid) -> SBase


        Returns the first child element that has the given 'metaid', or 'None'
        if no such object is found.

        Parameter 'metaid' is a string representing the metaid attribute of
        the object to retrieve.

        Returns a pointer to the SBase element with the given 'metaid'. If no
        such object is found this method returns 'None.'

        """
        return _libsbml.RenderInformationBase_getElementByMetaId(self, metaid)

RenderInformationBase_swigregister = _libsbml.RenderInformationBase_swigregister
RenderInformationBase_swigregister(RenderInformationBase)

class GradientBase(SBase):
    """

    [SBML 'render' package]

    Abstract base class for linear and radial gradients.

    The base class implements common structures to both gradient classes.
    Both gradients have an id attribute which is used to reference a
    gradient within other render extension constructs. The id of a
    gradient can be used to define the fill style of 2D objects like e.g.
    rectangles.

    Further, both gradient classes have a ListOfGradientStops objects
    which holds the GradientStop objects that define the gradient and both
    classes have an  attribute called spreadMethod which defines how a
    gradient is applied to an object.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GradientBase, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, GradientBase, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    PAD = _libsbml.GradientBase_PAD
    REFLECT = _libsbml.GradientBase_REFLECT
    REPEAT = _libsbml.GradientBase_REPEAT
    INVALID = _libsbml.GradientBase_INVALID

    def clone(self):
        """
        clone(GradientBase self) -> GradientBase


        Creates and returns a deep copy of this GradientBase object.

        Returns a (deep) copy of this GradientBase object.

        """
        return _libsbml.GradientBase_clone(self)

    __swig_destroy__ = _libsbml.delete_GradientBase
    __del__ = lambda self: None

    def getId(self):
        """
        getId(GradientBase self) -> string


        Returns the value of the 'id' attribute of this GradientBase.

        Returns the value of the 'id' attribute of this GradientBase as a
        string.

        """
        return _libsbml.GradientBase_getId(self)


    def getName(self):
        """
        getName(GradientBase self) -> string


        Returns the value of the 'name' attribute of this GradientBase.

        Returns the value of the 'name' attribute of this GradientBase as a
        string.

        """
        return _libsbml.GradientBase_getName(self)


    def getSpreadMethod(self):
        """
        getSpreadMethod(GradientBase self) -> int


        Returns the value of the 'spreadMethod' attribute of this
        GradientBase.

        Returns the value of the 'spreadMethod' attribute of this GradientBase
        as a int.

        The attribute 'spreadMethod' on a GradientBase object is used by
        GradientBase  elements to decide how gradients propagate over the
        whole element they are  applied to.  The following are the allowable
        values for 'spreadMethod':

        * ''pad',' the gradient color at the endpoint of the vector defines
        how  the gradient is continued beyond that point (default value).

        * ''reflect',' the gradient continues from end to start and then from
        start to end again and again.

        * ''repeat',' the gradient pattern is repeated from start to end over
        and over again.

        The possible values returned by this method are:

        * GRADIENT_SPREADMETHOD_PAD

        * GRADIENT_SPREADMETHOD_REFLECT

        * GRADIENT_SPREADMETHOD_REPEAT

        * GRADIENT_SPREAD_METHOD_INVALID

        """
        return _libsbml.GradientBase_getSpreadMethod(self)


    def getSpreadMethodAsString(self):
        """
        getSpreadMethodAsString(GradientBase self) -> string


        Returns the value of the 'spreadMethod' attribute of this
        GradientBase.

        Returns the value of the 'spreadMethod' attribute of this GradientBase
        as a string.

        The attribute 'spreadMethod' on a GradientBase object is used by
        GradientBase  elements to decide how gradients propagate over the
        whole element they are  applied to.  The following are the allowable
        values for 'spreadMethod':

        * ''pad',' the gradient color at the endpoint of the vector defines
        how  the gradient is continued beyond that point (default value).

        * ''reflect',' the gradient continues from end to start and then from
        start to end again and again.

        * ''repeat',' the gradient pattern is repeated from start to end over
        and over again.

        The possible values returned by this method are:

        * ''pad''

        * ''reflect''

        * ''repeat''

        * ''invalid''

        * ''(Unknown' GradientSpreadMethod value)'

        """
        return _libsbml.GradientBase_getSpreadMethodAsString(self)


    def getSpreadMethodString(self):
        """
        getSpreadMethodString(GradientBase self) -> string


        Returns the value of the 'spreadMethod' attribute of this
        GradientBase.

        Returns the value of the 'spreadMethod' attribute of this GradientBase
        as a string.

        The attribute 'spreadMethod' on a GradientBase object is used by
        GradientBase  elements to decide how gradients propagate over the
        whole element they are  applied to.  The following are the allowable
        values for 'spreadMethod':

        * ''pad',' the gradient color at the endpoint of the vector defines
        how  the gradient is continued beyond that point (default value).

        * ''reflect',' the gradient continues from end to start and then from
        start to end again and again.

        * ''repeat',' the gradient pattern is repeated from start to end over
        and over again.

        The possible values returned by this method are:

        * ''pad''

        * ''reflect''

        * ''repeat''

        * ''invalid''

        """
        return _libsbml.GradientBase_getSpreadMethodString(self)


    def isSetId(self):
        """
        isSetId(GradientBase self) -> bool


        Predicate returning 'True' if this GradientBase's 'id' attribute is
        set.

        Returns 'True' if this GradientBase's 'id' attribute has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.GradientBase_isSetId(self)


    def isSetName(self):
        """
        isSetName(GradientBase self) -> bool


        Predicate returning 'True' if this GradientBase's 'name' attribute is
        set.

        Returns 'True' if this GradientBase's 'name' attribute has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.GradientBase_isSetName(self)


    def isSetSpreadMethod(self):
        """
        isSetSpreadMethod(GradientBase self) -> bool


        Predicate returning 'True' if this GradientBase's 'spreadMethod'
        attribute is set.

        Returns 'True' if this GradientBase's 'spreadMethod' attribute has
        been set, otherwise 'False' is returned.

        The attribute 'spreadMethod' on a GradientBase object is used by
        GradientBase  elements to decide how gradients propagate over the
        whole element they are  applied to.  The following are the allowable
        values for 'spreadMethod':

        * ''pad',' the gradient color at the endpoint of the vector defines
        how  the gradient is continued beyond that point (default value).

        * ''reflect',' the gradient continues from end to start and then from
        start to end again and again.

        * ''repeat',' the gradient pattern is repeated from start to end over
        and over again.

        """
        return _libsbml.GradientBase_isSetSpreadMethod(self)


    def setId(self, id):
        """
        setId(GradientBase self, string id) -> int


        Sets the value of the 'id' attribute of this GradientBase.

        Parameter 'id' is the string value of the 'id' attribute to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        Calling this function with 'id' = 'None' or an empty string is
        equivalent to calling unsetId().

        """
        return _libsbml.GradientBase_setId(self, id)


    def setName(self, name):
        """
        setName(GradientBase self, string name) -> int


        Sets the value of the 'name' attribute of this GradientBase.

        Parameter 'name' is the string value of the 'name' attribute to be
        set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        Calling this function with 'name' = 'None' or an empty string is
        equivalent to calling unsetName().

        """
        return _libsbml.GradientBase_setName(self, name)


    def setSpreadMethod(self, *args):
        """
        setSpreadMethod(GradientBase self, GradientBase::SPREADMETHOD spreadMethod)
        setSpreadMethod(GradientBase self, GradientSpreadMethod_t const spreadMethod) -> int
        setSpreadMethod(GradientBase self, string spreadMethod) -> int


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            setSpreadMethod( GradientSpreadMethod_t spreadMethod)

        Sets the value of the 'spreadMethod' attribute of this GradientBase.

        Parameter 'spreadMethod' is int value of the 'spreadMethod' attribute
        to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        The attribute 'spreadMethod' on a GradientBase object is used by
        GradientBase  elements to decide how gradients propagate over the
        whole element they are  applied to.  The following are the allowable
        values for 'spreadMethod':

        * ''pad',' the gradient color at the endpoint of the vector defines
        how  the gradient is continued beyond that point (default value).

        * ''reflect',' the gradient continues from end to start and then from
        start to end again and again.

        * ''repeat',' the gradient pattern is repeated from start to end over
        and over again.

        ______________________________________________________________________
        Method variant with the following signature:

            setSpreadMethod(string spreadMethod)

        Sets the value of the 'spreadMethod' attribute of this GradientBase.

        Parameter 'spreadMethod' is string& of the 'spreadMethod' attribute to
        be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        The attribute 'spreadMethod' on a GradientBase object is used by
        GradientBase  elements to decide how gradients propagate over the
        whole element they are  applied to.  The following are the allowable
        values for 'spreadMethod':

        * ''pad',' the gradient color at the endpoint of the vector defines
        how  the gradient is continued beyond that point (default value).

        * ''reflect',' the gradient continues from end to start and then from
        start to end again and again.

        * ''repeat',' the gradient pattern is repeated from start to end over
        and over again.

        ______________________________________________________________________
        Method variant with the following signature:

            setSpreadMethod(SPREADMETHOD spreadMethod)

        Sets the value of the 'spreadMethod' attribute of this GradientBase.

        Parameter 'spreadMethod' is int value of the 'spreadMethod' attribute
        to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        The attribute 'spreadMethod' on a GradientBase object is used by
        GradientBase  elements to decide how gradients propagate over the
        whole element they are  applied to.  The following are the allowable
        values for 'spreadMethod':

        * ''pad',' the gradient color at the endpoint of the vector defines
        how  the gradient is continued beyond that point (default value).

        * ''reflect',' the gradient continues from end to start and then from
        start to end again and again.

        * ''repeat',' the gradient pattern is repeated from start to end over
        and over again.

        """
        return _libsbml.GradientBase_setSpreadMethod(self, *args)


    def unsetId(self):
        """
        unsetId(GradientBase self) -> int


        Unsets the value of the 'id' attribute of this GradientBase.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.GradientBase_unsetId(self)


    def unsetName(self):
        """
        unsetName(GradientBase self) -> int


        Unsets the value of the 'name' attribute of this GradientBase.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.GradientBase_unsetName(self)


    def unsetSpreadMethod(self):
        """
        unsetSpreadMethod(GradientBase self) -> int


        Unsets the value of the 'spreadMethod' attribute of this GradientBase.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        The attribute 'spreadMethod' on a GradientBase object is used by
        GradientBase  elements to decide how gradients propagate over the
        whole element they are  applied to.  The following are the allowable
        values for 'spreadMethod':

        * ''pad',' the gradient color at the endpoint of the vector defines
        how  the gradient is continued beyond that point (default value).

        * ''reflect',' the gradient continues from end to start and then from
        start to end again and again.

        * ''repeat',' the gradient pattern is repeated from start to end over
        and over again.

        """
        return _libsbml.GradientBase_unsetSpreadMethod(self)


    def getListOfGradientStops(self, *args):
        """
        getListOfGradientStops(GradientBase self) -> ListOfGradientStops
        getListOfGradientStops(GradientBase self) -> ListOfGradientStops


        Returns the ListOfGradientStops from this GradientBase.

        Returns the ListOfGradientStops from this GradientBase.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addGradientStop(), createGradientStop(), getGradientStop(),
        getGradientStop(), getNumGradientStops(), removeGradientStop(),
        removeGradientStop().

        """
        return _libsbml.GradientBase_getListOfGradientStops(self, *args)


    def getGradientStop(self, *args):
        """
        getGradientStop(GradientBase self, unsigned int n) -> GradientStop
        getGradientStop(GradientBase self, string sid) -> GradientStop
        getGradientStop(GradientBase self, unsigned int n) -> GradientStop


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getGradientStop(long n)

        Get a GradientStop from the GradientBase.

        Parameter 'n' is a long integer representing the index of the
        GradientStop to retrieve.

        Returns the nth GradientStop in the ListOfGradientStops within this
        GradientBase. If the index 'n' is invalid, 'None' is returned.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addGradientStop(), createGradientStop(), getGradientStop(),
        getNumGradientStops(), removeGradientStop(), removeGradientStop().

        ______________________________________________________________________
        Method variant with the following signature:

            getGradientStop(string sid)

        Get the GradientStop with the given id from the GradientBase.

        Parameter 'sid' is the id of the GradientStop to retrieve.

        Returns the GradientStop in the ListOfGradientStops with  the given
        'id' from this GradientBase. If no such GradientStop exists, 'None' is
        returned.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addGradientStop(), createGradientStop(), getGradientStop(),
        getNumGradientStops(), removeGradientStop(), removeGradientStop().

        """
        return _libsbml.GradientBase_getGradientStop(self, *args)


    def addGradientStop(self, gs):
        """
        addGradientStop(GradientBase self, GradientStop gs) -> int


        Adds a copy of the given GradientStop to this GradientBase.

        Parameter 'gs' is the GradientStop object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_PKG_VERSION_MISMATCH

        * LIBSBML_DUPLICATE_OBJECT_ID

        Note: This method should be used with some caution.  The fact that
        this method copies the object passed to it means that the caller will
        be left holding a physically different object instance than the one
        contained inside this object.  Changes made to the original object
        instance (such as resetting attribute values) will not affect the
        instance in this object.  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 other methods on this class
        (particularly a corresponding method whose name begins with the word
        create) for alternatives that do not lead to these issues.

        See also createGradientStop(), getGradientStop(), getGradientStop(),
        getNumGradientStops(), removeGradientStop(), removeGradientStop().

        """
        return _libsbml.GradientBase_addGradientStop(self, gs)


    def getNumGradientStops(self):
        """
        getNumGradientStops(GradientBase self) -> unsigned int


        Get the number of GradientStop objects in this GradientBase.

        Returns the number of GradientStop objects in this GradientBase.

        See also addGradientStop(), createGradientStop(), getGradientStop(),
        getGradientStop(), removeGradientStop(), removeGradientStop().

        """
        return _libsbml.GradientBase_getNumGradientStops(self)


    def createGradientStop(self):
        """
        createGradientStop(GradientBase self) -> GradientStop


        Creates a new GradientStop object, adds it to this GradientBase object
        and returns the GradientStop object created.

        Returns a new GradientStop object instance.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addGradientStop(), getGradientStop(), getGradientStop(),
        getNumGradientStops(), removeGradientStop(), removeGradientStop().

        """
        return _libsbml.GradientBase_createGradientStop(self)


    def removeGradientStop(self, *args):
        """
        removeGradientStop(GradientBase self, unsigned int n) -> GradientStop
        removeGradientStop(GradientBase self, string sid) -> GradientStop


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeGradientStop(long n)

        Removes the nth GradientStop from this GradientBase and returns a
        pointer to it.

        Parameter 'n' is a long integer representing the index of the
        GradientStop to remove.

        Returns a pointer to the nth GradientStop in this GradientBase.

        WARNING:

        The pointer that is returned by this function is owned by the caller,
        who is responsible for deleting it.  Any changes made to the element
        will not be reflected in any resulting SBML document unless the
        element is added to an SBML Document.  Even in this case, the
        element's deletion is still the responsibility of the caller with two
        exceptions: if it is used as the 'disownedItem' in the
        ListOf.appendAndOwn() or ListOf.insertAndOwn()  functions.  All other
        functions in libsbml add a copy of the element, and do not transfer
        ownership of the pointer.

        See also addGradientStop(), createGradientStop(), getGradientStop(),
        getGradientStop(), getNumGradientStops(), removeGradientStop().

        ______________________________________________________________________
        Method variant with the following signature:

            removeGradientStop(string sid)

        Removes the GradientStop with the given id from this GradientBase  and
        returns a pointer to it.

        Parameter 'sid' is the id of the GradientStop to remove.

        Returns a pointer to the nth GradientStop in this GradientBase.

        WARNING:

        The pointer that is returned by this function is owned by the caller,
        who is responsible for deleting it.  Any changes made to the element
        will not be reflected in any resulting SBML document unless the
        element is added to an SBML Document.  Even in this case, the
        element's deletion is still the responsibility of the caller with two
        exceptions: if it is used as the 'disownedItem' in the
        ListOf.appendAndOwn() or ListOf.insertAndOwn()  functions.  All other
        functions in libsbml add a copy of the element, and do not transfer
        ownership of the pointer.

        See also addGradientStop(), createGradientStop(), getGradientStop(),
        getGradientStop(), getNumGradientStops(), removeGradientStop().

        """
        return _libsbml.GradientBase_removeGradientStop(self, *args)


    def isLinearGradient(self):
        """
        isLinearGradient(GradientBase self) -> bool


        Predicate returning 'True' if this abstract GradientBase is of type
        LinearGradient

        Returns 'True' if this abstract GradientBase is of type
        LinearGradient, 'False' otherwise

        """
        return _libsbml.GradientBase_isLinearGradient(self)


    def isRadialGradient(self):
        """
        isRadialGradient(GradientBase self) -> bool


        Predicate returning 'True' if this abstract GradientBase is of type
        RadialGradient

        Returns 'True' if this abstract GradientBase is of type
        RadialGradient, 'False' otherwise

        """
        return _libsbml.GradientBase_isRadialGradient(self)


    def getElementName(self):
        """
        getElementName(GradientBase self) -> string


        Returns the XML element name of this GradientBase object.

        For GradientBase, the XML element name is always ''gradientBase'.'

        Returns the name of this element, i.e. ''gradientBase'.'

        """
        return _libsbml.GradientBase_getElementName(self)


    def setElementName(self, name):
        """
        setElementName(GradientBase self, string name)


        Internal implementation method.

        """
        return _libsbml.GradientBase_setElementName(self, name)


    def getTypeCode(self):
        """
        getTypeCode(GradientBase self) -> int


        Returns the libSBML type code for this GradientBase object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object:
        SBML_RENDER_GRADIENTDEFINITION.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.GradientBase_getTypeCode(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(GradientBase self) -> bool


        Predicate returning 'True' if all the required attributes for this
        GradientBase object have been set.

        Returns 'True' to indicate that all the required attributes of this
        GradientBase have been set, otherwise 'False' is returned.

        Note: The required attributes for the GradientBase object are:

        * 'id'

        """
        return _libsbml.GradientBase_hasRequiredAttributes(self)


    def connectToChild(self):
        """
        connectToChild(GradientBase self)


        Internal implementation method.

        """
        return _libsbml.GradientBase_connectToChild(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(GradientBase self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.GradientBase_enablePackageInternal(self, pkgURI, pkgPrefix, flag)


    def toXML(self):
        """
        toXML(GradientBase self) -> XMLNode


        Creates an XMLNode object from this GradientBase object.

        Returns the XMLNode with the XML representation for the  GradientBase
        object.

        This method is purely abstract and needs to be implemented by derived
        classes.

        """
        return _libsbml.GradientBase_toXML(self)


    def getElementBySId(self, id):
        """
        getElementBySId(GradientBase self, string id) -> SBase


        Returns the first child element that has the given 'id' in the model-
        wide SId namespace, or 'None' if no such object is found.

        Parameter 'id' is a string representing the id attribute of the object
        to retrieve.

        Returns a pointer to the SBase element with the given 'id'. If no such
        object is found, this method returns 'None.'

        """
        return _libsbml.GradientBase_getElementBySId(self, id)


    def getElementByMetaId(self, metaid):
        """
        getElementByMetaId(GradientBase self, string metaid) -> SBase


        Returns the first child element that has the given 'metaid', or 'None'
        if no such object is found.

        Parameter 'metaid' is a string representing the metaid attribute of
        the object to retrieve.

        Returns a pointer to the SBase element with the given 'metaid'. If no
        such object is found this method returns 'None.'

        """
        return _libsbml.GradientBase_getElementByMetaId(self, metaid)

GradientBase_swigregister = _libsbml.GradientBase_swigregister
GradientBase_swigregister(GradientBase)


def SpreadMethod_fromString(name):
    """SpreadMethod_fromString(char const * name) -> GradientBase::SPREADMETHOD"""
    return _libsbml.SpreadMethod_fromString(name)

def SpreadMethod_toString(method):
    """SpreadMethod_toString(GradientBase::SPREADMETHOD method) -> char const *"""
    return _libsbml.SpreadMethod_toString(method)
class Style(SBase):
    """

    [SBML 'render' package]

    Abstract base class for local and global styles.

    Local and global styles in the SBML Level 3 Render package have many
    attributes and methods in common.  These have been implemented in the
    abstract base class Style.

    A style is a graphical representation for certain layout objects. The
    assignment of styles to individual layout objects can either be done
    through layout object ids (local styles only), layout object types
    (SPECIES, COMPARTMENT, etc.) or layout object roles.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Style, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Style, name)
    __repr__ = _swig_repr

    def __init__(self, orig):
        """
        __init__(Style self, Style orig) -> Style


        [SBML 'render' package]

        Abstract base class for local and global styles.

        Local and global styles in the SBML Level 3 Render package have many
        attributes and methods in common.  These have been implemented in the
        abstract base class Style.

        A style is a graphical representation for certain layout objects. The
        assignment of styles to individual layout objects can either be done
        through layout object ids (local styles only), layout object types
        (SPECIES, COMPARTMENT, etc.) or layout object roles.

        """
        this = _libsbml.new_Style(orig)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(Style self) -> Style


        Creates and returns a deep copy of this Style object.

        Returns a (deep) copy of this Style object.

        """
        return _libsbml.Style_clone(self)

    __swig_destroy__ = _libsbml.delete_Style
    __del__ = lambda self: None

    def getId(self):
        """
        getId(Style self) -> string


        Returns the value of the 'id' attribute of this Style.

        Returns the value of the 'id' attribute of this Style as a string.

        """
        return _libsbml.Style_getId(self)


    def getName(self):
        """
        getName(Style self) -> string


        Returns the value of the 'name' attribute of this Style.

        Returns the value of the 'name' attribute of this Style as a string.

        """
        return _libsbml.Style_getName(self)


    def isSetId(self):
        """
        isSetId(Style self) -> bool


        Predicate returning 'True' if this Style's 'id' attribute is set.

        Returns 'True' if this Style's 'id' attribute has been set, otherwise
        'False' is returned.

        """
        return _libsbml.Style_isSetId(self)


    def isSetName(self):
        """
        isSetName(Style self) -> bool


        Predicate returning 'True' if this Style's 'name' attribute is set.

        Returns 'True' if this Style's 'name' attribute has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.Style_isSetName(self)


    def setId(self, id):
        """
        setId(Style self, string id) -> int


        Sets the value of the 'id' attribute of this Style.

        Parameter 'id' is string& value of the 'id' attribute to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        Calling this function with 'id' = 'None' or an empty string is
        equivalent to calling unsetId().

        """
        return _libsbml.Style_setId(self, id)


    def setName(self, name):
        """
        setName(Style self, string name) -> int


        Sets the value of the 'name' attribute of this Style.

        Parameter 'name' is string& value of the 'name' attribute to be set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        Calling this function with 'name' = 'None' or an empty string is
        equivalent to calling unsetName().

        """
        return _libsbml.Style_setName(self, name)


    def unsetId(self):
        """
        unsetId(Style self) -> int


        Unsets the value of the 'id' attribute of this Style.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Style_unsetId(self)


    def unsetName(self):
        """
        unsetName(Style self) -> int


        Unsets the value of the 'name' attribute of this Style.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Style_unsetName(self)


    def getRoleList(self, *args):
        """
        getRoleList(Style self) -> StringSet
        getRoleList(Style self) -> StringSet


        Returns the value of the 'roleList' attribute of this Style.

        Returns the value of the 'roleList' attribute of this Style as a
        string.

        """
        return _libsbml.Style_getRoleList(self, *args)


    def getNumRoles(self):
        """
        getNumRoles(Style self) -> unsigned int


        Returns the number of ids in the role list.

        Returns the number of roles in the role list.

        """
        return _libsbml.Style_getNumRoles(self)


    def isInRoleList(self, role):
        """
        isInRoleList(Style self, string role) -> bool


        Checks whether a given role is in the role list.

        Parameter 'role' is role string to check for in the role list.

        """
        return _libsbml.Style_isInRoleList(self, role)


    def addRole(self, role):
        """
        addRole(Style self, string role) -> int


        Adds an id to the role list.

        Parameter 'role' is New role to be added to the role list.

        """
        return _libsbml.Style_addRole(self, role)


    def createRoleString(self):
        """
        createRoleString(Style self) -> string


        Returns the string of all roles

        """
        return _libsbml.Style_createRoleString(self)


    def removeRole(self, role):
        """
        removeRole(Style self, string role) -> int


        Removes the given role from the role list.

        Parameter 'role' is role string to be removed from the role list.

        """
        return _libsbml.Style_removeRole(self, role)


    def setRoleList(self, roleList):
        """
        setRoleList(Style self, StringSet roleList) -> int


        Sets the complete role list to a copy of the given list.

        Parameter 'roleList' is New list of role strings to be set on the
        style.

        """
        return _libsbml.Style_setRoleList(self, roleList)


    def getTypeList(self, *args):
        """
        getTypeList(Style self) -> StringSet
        getTypeList(Style self) -> StringSet


        Returns the type list.

        Returns reference to the type list.

        The attribute 'typeList' for LocalStyle and GlobalStyle objects
        contains a list of StyleType entries that describe what sorts of
        object to apply the style to. In the SBML Level 3 Version 1 Render
        specification, the following are the allowable entries in a
        whitespace-separated 'typeList':

        * ''COMPARTMENTGLYPH':' The style is to be applied to all compartment
        glyphs.

        * ''SPECIESGLYPH':' The style is to be applied to all species glyphs.

        * ''REACTIONGLYPH':' The style is to be applied to all reaction
        glyphs.

        * ''SPECIESREFERENCEGLYPH':' The style is to be applied to all species
        reference glyphs.

        * ''TEXTGLYPH':' The style is to be applied to all text glyphs.

        * ''GENERALGLYPH':' The style is to be applied to all general glyphs.

        * ''GRAPHICALOBJECT':' The style is to be applied to all graphical
        objects.

        * ''ANY':' The style is to be applied to any and all glyphs and
        graphical objects.  Equivalent to explicitly listing all other
        keywords.

        """
        return _libsbml.Style_getTypeList(self, *args)


    def getNumTypes(self):
        """
        getNumTypes(Style self) -> unsigned int


        Returns the number of types in the type list.

        Returns number of types in type list.

        """
        return _libsbml.Style_getNumTypes(self)


    def isInTypeList(self, type):
        """
        isInTypeList(Style self, string type) -> bool


        Checks whether a given type string is in the type list.

        Parameter 'type' is string to be searched for in the type list

        Returns 'True' or 'False' depending on whether the given string was
        found in the type list.

        The attribute 'typeList' for LocalStyle and GlobalStyle objects
        contains a list of StyleType entries that describe what sorts of
        object to apply the style to. In the SBML Level 3 Version 1 Render
        specification, the following are the allowable entries in a
        whitespace-separated 'typeList':

        * ''COMPARTMENTGLYPH':' The style is to be applied to all compartment
        glyphs.

        * ''SPECIESGLYPH':' The style is to be applied to all species glyphs.

        * ''REACTIONGLYPH':' The style is to be applied to all reaction
        glyphs.

        * ''SPECIESREFERENCEGLYPH':' The style is to be applied to all species
        reference glyphs.

        * ''TEXTGLYPH':' The style is to be applied to all text glyphs.

        * ''GENERALGLYPH':' The style is to be applied to all general glyphs.

        * ''GRAPHICALOBJECT':' The style is to be applied to all graphical
        objects.

        * ''ANY':' The style is to be applied to any and all glyphs and
        graphical objects.  Equivalent to explicitly listing all other
        keywords.

        """
        return _libsbml.Style_isInTypeList(self, type)


    def addType(self, type):
        """
        addType(Style self, string type) -> int


        Adds a type string to the type list.

        Parameter 'type' is new type string to be added to the type list

        """
        return _libsbml.Style_addType(self, type)


    def createTypeString(self):
        """
        createTypeString(Style self) -> string


        Returns the string of all types

        """
        return _libsbml.Style_createTypeString(self)


    def removeType(self, type):
        """
        removeType(Style self, string type) -> int


        Removes a type string from the type list.

        Parameter 'type' is type string to be removed from the type list.

        """
        return _libsbml.Style_removeType(self, type)


    def setTypeList(self, typeList):
        """
        setTypeList(Style self, StringSet typeList) -> int


        Sets the complete type list to a copy of the given list.

        Parameter 'typeList' is the list of types to be set for the style.

        The attribute 'typeList' for LocalStyle and GlobalStyle objects
        contains a list of StyleType entries that describe what sorts of
        object to apply the style to. In the SBML Level 3 Version 1 Render
        specification, the following are the allowable entries in a
        whitespace-separated 'typeList':

        * ''COMPARTMENTGLYPH':' The style is to be applied to all compartment
        glyphs.

        * ''SPECIESGLYPH':' The style is to be applied to all species glyphs.

        * ''REACTIONGLYPH':' The style is to be applied to all reaction
        glyphs.

        * ''SPECIESREFERENCEGLYPH':' The style is to be applied to all species
        reference glyphs.

        * ''TEXTGLYPH':' The style is to be applied to all text glyphs.

        * ''GENERALGLYPH':' The style is to be applied to all general glyphs.

        * ''GRAPHICALOBJECT':' The style is to be applied to all graphical
        objects.

        * ''ANY':' The style is to be applied to any and all glyphs and
        graphical objects.  Equivalent to explicitly listing all other
        keywords.

        """
        return _libsbml.Style_setTypeList(self, typeList)


    def getGroup(self, *args):
        """
        getGroup(Style self) -> RenderGroup
        getGroup(Style self) -> RenderGroup


        Returns the value of the 'group' element of this Style.

        Returns the value of the 'group' element of this Style as a
        RenderGroup.

        """
        return _libsbml.Style_getGroup(self, *args)


    def isSetGroup(self):
        """
        isSetGroup(Style self) -> bool


        Predicate returning 'True' if this Style's 'group' element is set.

        Returns 'True' if this Style's 'group' element has been set, otherwise
        'False' is returned.

        """
        return _libsbml.Style_isSetGroup(self)


    def setGroup(self, group):
        """
        setGroup(Style self, RenderGroup group) -> int


        Sets the value of the 'group' element of this Style.

        Parameter 'group' is RenderGroup value of the 'group' element to be
        set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Style_setGroup(self, group)


    def createGroup(self):
        """
        createGroup(Style self) -> RenderGroup


        Creates a new RenderGroup object, adds it to this Style object and
        returns the RenderGroup object created.

        Returns a new RenderGroup object instance.

        """
        return _libsbml.Style_createGroup(self)


    def unsetGroup(self):
        """
        unsetGroup(Style self) -> int


        Unsets the value of the 'group' element of this Style.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Style_unsetGroup(self)


    def isGlobalStyle(self):
        """
        isGlobalStyle(Style self) -> bool


        Predicate returning 'True' if this abstract Style is of type
        GlobalStyle

        Returns 'True' if this abstract Style is of type GlobalStyle, 'False'
        otherwise

        """
        return _libsbml.Style_isGlobalStyle(self)


    def isLocalStyle(self):
        """
        isLocalStyle(Style self) -> bool


        Predicate returning 'True' if this abstract Style is of type
        LocalStyle

        Returns 'True' if this abstract Style is of type LocalStyle, 'False'
        otherwise

        """
        return _libsbml.Style_isLocalStyle(self)


    def getElementName(self):
        """
        getElementName(Style self) -> string


        Returns the XML element name of this Style object.

        For Style, the XML element name is always ''style'.'

        Returns the name of this element, i.e. ''style'.'

        """
        return _libsbml.Style_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(Style self) -> int


        Returns the libSBML type code for this Style object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_RENDER_STYLE_BASE.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.Style_getTypeCode(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(Style self) -> bool


        Predicate returning 'True' if all the required attributes for this
        Style object have been set.

        Returns 'True' to indicate that all the required attributes of this
        Style have been set, otherwise 'False' is returned.

        """
        return _libsbml.Style_hasRequiredAttributes(self)


    def connectToChild(self):
        """
        connectToChild(Style self)


        Internal implementation method.

        """
        return _libsbml.Style_connectToChild(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(Style self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.Style_enablePackageInternal(self, pkgURI, pkgPrefix, flag)


    def getElementBySId(self, id):
        """
        getElementBySId(Style self, string id) -> SBase


        Returns the first child element that has the given 'id' in the model-
        wide SId namespace, or 'None' if no such object is found.

        Parameter 'id' is a string representing the id attribute of the object
        to retrieve.

        Returns a pointer to the SBase element with the given 'id'. If no such
        object is found, this method returns 'None.'

        """
        return _libsbml.Style_getElementBySId(self, id)


    def getElementByMetaId(self, metaid):
        """
        getElementByMetaId(Style self, string metaid) -> SBase


        Returns the first child element that has the given 'metaid', or 'None'
        if no such object is found.

        Parameter 'metaid' is a string representing the metaid attribute of
        the object to retrieve.

        Returns a pointer to the SBase element with the given 'metaid'. If no
        such object is found this method returns 'None.'

        """
        return _libsbml.Style_getElementByMetaId(self, metaid)


    def toXML(self):
        """
        toXML(Style self) -> XMLNode


        Creates an XMLNode object from this Style object.

        Returns the XMLNode with the XML representation for the  Style object.

        """
        return _libsbml.Style_toXML(self)

Style_swigregister = _libsbml.Style_swigregister
Style_swigregister(Style)

class ColorDefinition(SBase):
    """

    [SBML 'render' package]

    Definition of an identifier for an RGBA color value.

    A ColorDefinition defines an identifier representing an RGBA value,
    which can then be referenced in other render extension constructs.
    For example, an identifier can be defined for 'lightyellow' and this
    may be more descriptive to use in graphs of models than the
    corresponding RGBA value.

    A ColorDefinition has two mandatory attributes: the id for the color
    definition and the corresponding RGBA value. The RGBA value has the
    same notation as in HTML files or CSS style sheets. It starts with the
    '#' character followed by 8 digit hexadecimal string.  Optionally the
    alpha part can be omitted, in which case it defaults to 'FF.'

    Examples of valid values strings are ''#000000'' and ''#000000FF'' for
    fully opaque black, and ''#FF000010'' for an almost completely
    transparent red.

    Internally, the RGBA components are stored as integer values in the
    range of 0 to 255 and most methods in the implementation of the
    libSBML "render" extension use integer values instead of the
    hexadecimal value string.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ColorDefinition, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ColorDefinition, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ColorDefinition self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ColorDefinition
        __init__(ColorDefinition self, unsigned int level, unsigned int version) -> ColorDefinition
        __init__(ColorDefinition self, unsigned int level) -> ColorDefinition
        __init__(ColorDefinition self) -> ColorDefinition
        __init__(ColorDefinition self, RenderPkgNamespaces renderns) -> ColorDefinition
        __init__(ColorDefinition self, XMLNode node, unsigned int l2version=4) -> ColorDefinition
        __init__(ColorDefinition self, XMLNode node) -> ColorDefinition
        __init__(ColorDefinition self, RenderPkgNamespaces renderns, unsigned char r, unsigned char g, unsigned char b, unsigned char a=255) -> ColorDefinition
        __init__(ColorDefinition self, RenderPkgNamespaces renderns, unsigned char r, unsigned char g, unsigned char b) -> ColorDefinition
        __init__(ColorDefinition self, RenderPkgNamespaces renderns, string id) -> ColorDefinition
        __init__(ColorDefinition self, RenderPkgNamespaces renderns, string id, unsigned char r, unsigned char g, unsigned char b, unsigned char a=255) -> ColorDefinition
        __init__(ColorDefinition self, RenderPkgNamespaces renderns, string id, unsigned char r, unsigned char g, unsigned char b) -> ColorDefinition
        __init__(ColorDefinition self, ColorDefinition orig) -> ColorDefinition


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ColorDefinition(long level =
        RenderExtension.getDefaultLevel(), long version =
        RenderExtension.getDefaultVersion(), long pkgVersion =
        RenderExtension.getDefaultPackageVersion())

        Creates a new ColorDefinition using the given SBML Level, Version and
        "render" package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        ColorDefinition.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this ColorDefinition.

        Parameter 'pkgVersion' is a long integer, the SBML Render Version to
        assign to this ColorDefinition.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            ColorDefinition(XMLNode node, long l2version=4)

        Creates a new ColorDefinition object from the given XMLNode object.

        The XMLNode object must contain a valid XML representation of a
        ColorDefinition object as defined in the "render" package
        specification.  This method is normally called when "render"
        information is read from a file and should normally not have to be
        called explicitly.

        (FOR BACKWARD COMPATIBILITY)

        Parameter 'node' is the XMLNode object reference that describes the
        ColorDefinition object to be instantiated. Parameter 'l2version' is an
        integer indicating the version of SBML Level 2

        ______________________________________________________________________
        Method variant with the following signature:

            ColorDefinition(RenderPkgNamespaces renderns)

        Creates a new ColorDefinition using the given RenderPkgNamespaces
        object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'renderns' is the RenderPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        ______________________________________________________________________
        Method variant with the following signature:

            ColorDefinition(ColorDefinition orig)

        Copy constructor for ColorDefinition.

        Parameter 'orig' is the ColorDefinition instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            ColorDefinition(RenderPkgNamespaces renderns, unsigned char
        r,unsigned char g,unsigned char b,unsigned char a=255)

        Constructor which sets the ColorDefinition to the given RGBA values.

        Parameter 'renderns' is The namespace object for the Render package.
        Parameter 'r' is Red component value. Has to be in the range of 0 to
        255. Parameter 'g' is Green component value. Has to be in the range of
        0 to 255. Parameter 'b' is Blue component value. Has to be in the
        range of 0 to 255. Parameter 'a' is Alpha component value. Has to be
        in the range of 0 to 255.  The alpha component can be omitted. In that
        case it has a default value of 255.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        WARNING:

        This constructor is deprecated. The new libSBML API uses constructors
        that either take the SBML Level and Version, or take an SBMLNamespaces
        object.

        ______________________________________________________________________
        Method variant with the following signature:

            ColorDefinition(RenderPkgNamespaces renderns, string id)

        Constructor which sets the ColorDefinition to completely opaque black
        and sets the id to the given string.

        Parameter 'renderns' is The namespace object for the Render package.
        Parameter 'id' is the id of the color definition. The user has to make
        sure  that the id is unique within the given set of color definitions.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        WARNING:

        This constructor is deprecated. The new libSBML API uses constructors
        that either take the SBML Level and Version, or take an SBMLNamespaces
        object.

        ______________________________________________________________________
        Method variant with the following signature:

            ColorDefinition(RenderPkgNamespaces renderns, string
        id,unsigned char r,unsigned char g,unsigned char b,unsigned char
        a=255)

        Constructor which sets the ColorDefinition to the given RGBA values
        and sets the id.

        Parameter 'renderns' is The namespace object for the Render package.
        Parameter 'id' is the id of the color definition. The user has to make
        sure  that the id is unique within the given set of color definitions.
        Parameter 'r' is Red component value. Has to be in the range of 0 to
        255. Parameter 'g' is Green component value. Has to be in the range of
        0 to 255. Parameter 'b' is Blue component value. Has to be in the
        range of 0 to 255. Parameter 'a' is Alpha component value. Has to be
        in the range of 0 to 255.  The alpha component can be omitted. In that
        case it has a default value of 255.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        WARNING:

        This constructor is deprecated. The new libSBML API uses constructors
        that either take the SBML Level and Version, or take an SBMLNamespaces
        object.

        """
        this = _libsbml.new_ColorDefinition(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ColorDefinition self) -> ColorDefinition


        Creates and returns a deep copy of this ColorDefinition object.

        Returns a (deep) copy of this ColorDefinition object.

        """
        return _libsbml.ColorDefinition_clone(self)

    __swig_destroy__ = _libsbml.delete_ColorDefinition
    __del__ = lambda self: None

    def getId(self):
        """
        getId(ColorDefinition self) -> string


        Returns the value of the 'id' attribute of this ColorDefinition.

        Returns the value of the 'id' attribute of this ColorDefinition as a
        string.

        """
        return _libsbml.ColorDefinition_getId(self)


    def getName(self):
        """
        getName(ColorDefinition self) -> string


        Returns the value of the 'name' attribute of this ColorDefinition.

        Returns the value of the 'name' attribute of this ColorDefinition as a
        string.

        """
        return _libsbml.ColorDefinition_getName(self)


    def getValue(self):
        """
        getValue(ColorDefinition self) -> string


        Returns the value of the 'value' attribute of this ColorDefinition.

        Returns the value of the 'value' attribute of this ColorDefinition as
        a string.

        """
        return _libsbml.ColorDefinition_getValue(self)


    def getRed(self):
        """
        getRed(ColorDefinition self) -> unsigned char


        Returns the red color component.

        Returns the red color component for the ColorDefinition.

        """
        return _libsbml.ColorDefinition_getRed(self)


    def getGreen(self):
        """
        getGreen(ColorDefinition self) -> unsigned char


        Returns the green color component.

        Returns the green color component for the ColorDefinition.

        """
        return _libsbml.ColorDefinition_getGreen(self)


    def getBlue(self):
        """
        getBlue(ColorDefinition self) -> unsigned char


        Returns the blue color component.

        Returns the blue color component for the ColorDefinition.

        """
        return _libsbml.ColorDefinition_getBlue(self)


    def getAlpha(self):
        """
        getAlpha(ColorDefinition self) -> unsigned char


        Returns the alpha color component.

        Returns the alpha color component for the ColorDefinition.

        """
        return _libsbml.ColorDefinition_getAlpha(self)


    def isSetId(self):
        """
        isSetId(ColorDefinition self) -> bool


        Predicate returning 'True' if this ColorDefinition's 'id' attribute is
        set.

        Returns 'True' if this ColorDefinition's 'id' attribute has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.ColorDefinition_isSetId(self)


    def isSetName(self):
        """
        isSetName(ColorDefinition self) -> bool


        Predicate returning 'True' if this ColorDefinition's 'name' attribute
        is set.

        Returns 'True' if this ColorDefinition's 'name' attribute has been
        set, otherwise 'False' is returned.

        """
        return _libsbml.ColorDefinition_isSetName(self)


    def isSetValue(self):
        """
        isSetValue(ColorDefinition self) -> bool


        Predicate returning 'True' if this ColorDefinition's 'value' attribute
        is set.

        Returns 'True' if this ColorDefinition's 'value' attribute has been
        set, otherwise 'False' is returned.

        """
        return _libsbml.ColorDefinition_isSetValue(self)


    def setId(self, id):
        """
        setId(ColorDefinition self, string id) -> int


        Sets the value of the 'id' attribute of this ColorDefinition.

        Parameter 'id' is string& value of the 'id' attribute to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        Calling this function with 'id' = 'None' or an empty string is
        equivalent to calling unsetId().

        """
        return _libsbml.ColorDefinition_setId(self, id)


    def setName(self, name):
        """
        setName(ColorDefinition self, string name) -> int


        Sets the value of the 'name' attribute of this ColorDefinition.

        Parameter 'name' is string& value of the 'name' attribute to be set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        Calling this function with 'name' = 'None' or an empty string is
        equivalent to calling unsetName().

        """
        return _libsbml.ColorDefinition_setName(self, name)


    def setValue(self, value):
        """
        setValue(ColorDefinition self, string value) -> int


        Sets the value of the 'value' attribute of this ColorDefinition.

        Parameter 'value' is string& value of the 'value' attribute to be set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        Calling this function with 'value' = 'None' or an empty string is
        equivalent to calling unsetValue().

        """
        return _libsbml.ColorDefinition_setValue(self, value)


    def setRed(self, c):
        """
        setRed(ColorDefinition self, unsigned char c)


        Sets the red color component.

        Parameter 'c' is the new red component value for the color definition.

        """
        return _libsbml.ColorDefinition_setRed(self, c)


    def setGreen(self, c):
        """
        setGreen(ColorDefinition self, unsigned char c)


        Sets the green color component.

        Parameter 'c' is the new green component value for the color
        definition.

        """
        return _libsbml.ColorDefinition_setGreen(self, c)


    def setBlue(self, c):
        """
        setBlue(ColorDefinition self, unsigned char c)


        Sets the blue color component.

        Parameter 'c' is the new blue component value for the color
        definition.

        """
        return _libsbml.ColorDefinition_setBlue(self, c)


    def setAlpha(self, c):
        """
        setAlpha(ColorDefinition self, unsigned char c)


        Sets alpha red color component.

        Parameter 'c' is the new alpha component value for the color
        definition.

        """
        return _libsbml.ColorDefinition_setAlpha(self, c)


    def setRGBA(self, r, g, b, a=255):
        """
        setRGBA(ColorDefinition self, unsigned char r, unsigned char g, unsigned char b, unsigned char a=255)
        setRGBA(ColorDefinition self, unsigned char r, unsigned char g, unsigned char b)


        Sets the red green, blue and alpha color component. The alpha value is
        optional and defaults to 255 if not given. Parameter 'r' is Red
        component value. Has to be in the range of 0 to 255. Parameter 'g' is
        Green component value. Has to be in the range of 0 to 255. Parameter
        'b' is Blue component value. Has to be in the range of 0 to 255.
        Parameter 'a' is Alpha component value. Has to be in the range of 0 to
        255.  The alpha component can be omitted. In that case it has a
        default value of 255.

        """
        return _libsbml.ColorDefinition_setRGBA(self, r, g, b, a)


    def setColorValue(self, valueString):
        """
        setColorValue(ColorDefinition self, string valueString) -> bool


        Sets the color value from a given value string.

        If the string is not a valid value string, the color value is set to
        black and 'False' is returned.

        Parameter 'valueString' is A  reference to a string that represents a
        valid color value, e.g. ''#FFFFFFFF'' for fully opaque white.

        Returns 'True' or 'False' depending on whether setting the color value
        from the string was successfull.

        """
        return _libsbml.ColorDefinition_setColorValue(self, valueString)


    def createValueString(self):
        """
        createValueString(ColorDefinition self) -> string


        Creates a string that represents the current color value.

        Returns The string representation of the color value.

        """
        return _libsbml.ColorDefinition_createValueString(self)


    def unsetId(self):
        """
        unsetId(ColorDefinition self) -> int


        Unsets the value of the 'id' attribute of this ColorDefinition.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.ColorDefinition_unsetId(self)


    def unsetName(self):
        """
        unsetName(ColorDefinition self) -> int


        Unsets the value of the 'name' attribute of this ColorDefinition.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.ColorDefinition_unsetName(self)


    def unsetValue(self):
        """
        unsetValue(ColorDefinition self) -> int


        Unsets the value of the 'value' attribute of this ColorDefinition.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.ColorDefinition_unsetValue(self)


    def getElementName(self):
        """
        getElementName(ColorDefinition self) -> string


        Returns the XML element name of this ColorDefinition object.

        For ColorDefinition, the XML element name is always
        ''colorDefinition'.'

        Returns the name of this element, i.e. ''colorDefinition'.'

        """
        return _libsbml.ColorDefinition_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(ColorDefinition self) -> int


        Returns the libSBML type code for this ColorDefinition object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object:
        SBML_RENDER_COLORDEFINITION.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ColorDefinition_getTypeCode(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(ColorDefinition self) -> bool


        Predicate returning 'True' if all the required attributes for this
        ColorDefinition object have been set.

        Returns 'True' to indicate that all the required attributes of this
        ColorDefinition have been set, otherwise 'False' is returned.

        Note: The required attributes for the ColorDefinition object are:

        * 'id'

        * 'value'

        """
        return _libsbml.ColorDefinition_hasRequiredAttributes(self)


    def hasRequiredAttributesNoDefaults(self):
        """
        hasRequiredAttributesNoDefaults(ColorDefinition self) -> bool


        Internal implementation method.

        """
        return _libsbml.ColorDefinition_hasRequiredAttributesNoDefaults(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(ColorDefinition self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.ColorDefinition_enablePackageInternal(self, pkgURI, pkgPrefix, flag)


    def toXML(self):
        """
        toXML(ColorDefinition self) -> XMLNode


        Creates an XMLNode object from this ColorDefinition object.

        Returns the XMLNode with the XML representation for the
        ColorDefinition object.

        """
        return _libsbml.ColorDefinition_toXML(self)

ColorDefinition_swigregister = _libsbml.ColorDefinition_swigregister
ColorDefinition_swigregister(ColorDefinition)

class RelAbsVector(_object):
    """

    [SBML 'render' package]

    Vectors with an absolute value and a relative value.

    For many elements in the render extension, it is necessary to specify
    coordinates not in terms of absolute values, but rather in terms of
    relative values or even a combination of absolute and relative values.
    Such a pair of values where one represents an absolute value and the
    other represents a relative value can be expressed by a RelAbsVector.
    The RelAbsVector class represents a pair of numerical values where one
    value represents an absolute value and the other value is a relative
    value in percent.

    The relative and absolute values to initialize a RelAbsVector object
    can either be given as numerical datatypes (double) or as a valid
    value string.  A value string is a combination of an absolute value
    and a relative value and the absolute value if given has to come
    first. So valid value strings would be: '5.0e3+20%', or '100%' or '4'.

    """

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RelAbsVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RelAbsVector, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(RelAbsVector self, double a=0.0, double r=0.0) -> RelAbsVector
        __init__(RelAbsVector self, double a=0.0) -> RelAbsVector
        __init__(RelAbsVector self) -> RelAbsVector
        __init__(RelAbsVector self, string coordString) -> RelAbsVector
        __init__(RelAbsVector self, RelAbsVector orig) -> RelAbsVector


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            RelAbsVector(double a=0.0, double r=0.0)

        Constructor with two values. First value sets the absolute value,
        second sets the relative value (%).

        Parameter 'a' is absolute value Parameter 'r' is relative value in %
        (50 -> 50%)

        ______________________________________________________________________
        Method variant with the following signature:

            RelAbsVector(string coordString)

        Constructor with a value string. If the string does not represent a
        valid value, the relative and the absolute component of the
        RelAbsVector are set to NaN.

        Parameter 'coordString' is value as a string

        ______________________________________________________________________
        Method variant with the following signature:

            RelAbsVector(RelAbsVector orig)

        Copy constructor for RelAbsVector.

        Parameter 'orig' is the RelAbsVector instance to copy.

        """
        this = _libsbml.new_RelAbsVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(RelAbsVector self) -> RelAbsVector


        Creates and returns a deep copy of this RelAbsVector object.

        Returns a (deep) copy of this RelAbsVector object.

        """
        return _libsbml.RelAbsVector_clone(self)

    __swig_destroy__ = _libsbml.delete_RelAbsVector
    __del__ = lambda self: None

    def getAbsoluteValue(self):
        """
        getAbsoluteValue(RelAbsVector self) -> double


        Returns the absolute coordinate value.

        Returns absolute value

        """
        return _libsbml.RelAbsVector_getAbsoluteValue(self)


    def getRelativeValue(self):
        """
        getRelativeValue(RelAbsVector self) -> double


        Returns the relative coordinate value.

        Returns absolute value

        """
        return _libsbml.RelAbsVector_getRelativeValue(self)


    def getCoordinate(self):
        """
        getCoordinate(RelAbsVector self) -> string


        Returns the coordinate value.

        Returns absolute value

        """
        return _libsbml.RelAbsVector_getCoordinate(self)


    def isSetAbsoluteValue(self):
        """
        isSetAbsoluteValue(RelAbsVector self) -> bool


        Predicate returning 'True' if this RelAbsVector's 'abs' attribute is
        set.

        Returns 'True' if this RelAbsVector's 'abs' attribute has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.RelAbsVector_isSetAbsoluteValue(self)


    def isSetRelativeValue(self):
        """
        isSetRelativeValue(RelAbsVector self) -> bool


        Predicate returning 'True' if this RelAbsVector's 'rel' attribute is
        set.

        Returns 'True' if this RelAbsVector's 'rel' attribute has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.RelAbsVector_isSetRelativeValue(self)


    def isSetCoordinate(self):
        """
        isSetCoordinate(RelAbsVector self) -> bool


        Predicate returning 'True' if this RelAbsVector's coordinate attribute
        is set.

        Returns 'True' if this RelAbsVector's coordinate attribute has been
        set, otherwise 'False' is returned.

        """
        return _libsbml.RelAbsVector_isSetCoordinate(self)


    def setAbsoluteValue(self, abs):
        """
        setAbsoluteValue(RelAbsVector self, double abs) -> int


        Sets the absolute coordinate value.

        Calling this function with an argument of '0.0' or 'NaN' is equivalent
        to unsetting the value.

        Parameter 'abs' is double value of the 'abs' attribute to be set.

        """
        return _libsbml.RelAbsVector_setAbsoluteValue(self, abs)


    def setRelativeValue(self, rel):
        """
        setRelativeValue(RelAbsVector self, double rel) -> int


        Sets the relative coordinate value.

        Calling this function with an argument of '0.0' or 'NaN' is equivalent
        to unsetting the value.

        Parameter 'rel' is double value of the 'rel' attribute to be set.

        """
        return _libsbml.RelAbsVector_setRelativeValue(self, rel)


    def setCoordinate(self, *args):
        """
        setCoordinate(RelAbsVector self, double abs, double rel=0.0) -> int
        setCoordinate(RelAbsVector self, double abs) -> int
        setCoordinate(RelAbsVector self, string coordString) -> int


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            setCoordinate(double abs,double rel=0.0)

        Sets the relative and absolute value.

        Calling this function with an argument of '0.0' or 'NaN' is equivalent
        to unsetting the value.

        Parameter 'abs' is absolute value Parameter 'rel' is relative value.
        If the relative value is omitted, it is set to 0.

        ______________________________________________________________________
        Method variant with the following signature:

            setCoordinate(string coordString)

        Sets the coordinates from the given string. If the string does not
        represent a valid value, the relative and the absolute component of
        the RelAbsVector are set to NaN.

        Calling this function with either cooredinate having a value of
        ''0.0''  or ''NaN'' is equivalent to unsetting the value.

        Parameter 'coordString' is value string

        """
        return _libsbml.RelAbsVector_setCoordinate(self, *args)


    def unsetAbsoluteValue(self):
        """
        unsetAbsoluteValue(RelAbsVector self) -> int


        Unsets the value of the 'abs' attribute of this RelAbsVector.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.RelAbsVector_unsetAbsoluteValue(self)


    def unsetRelativeValue(self):
        """
        unsetRelativeValue(RelAbsVector self) -> int


        Unsets the value of the relative coordinate attribute of this
        RelAbsVector.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.RelAbsVector_unsetRelativeValue(self)


    def unsetCoordinate(self):
        """
        unsetCoordinate(RelAbsVector self) -> int


        Unsets the value of the 'rel' attribute of this RelAbsVector.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.RelAbsVector_unsetCoordinate(self)


    def __add__(self, other):
        """__add__(RelAbsVector self, RelAbsVector other) -> RelAbsVector"""
        return _libsbml.RelAbsVector___add__(self, other)


    def __truediv__(self, *args):
        return _libsbml.RelAbsVector___truediv__(self, *args)
    __div__ = __truediv__



    def __eq__(self, other):
        """__eq__(RelAbsVector self, RelAbsVector other) -> bool"""
        return _libsbml.RelAbsVector___eq__(self, other)


    def __ne__(self, other):
        """__ne__(RelAbsVector self, RelAbsVector other) -> bool"""
        return _libsbml.RelAbsVector___ne__(self, other)


    def empty(self):
        """
        empty(RelAbsVector self) -> bool


        Returns an indication whether this element has been set  (i.e., no
        zero entries for either relative or absolute coordinate)

        """
        return _libsbml.RelAbsVector_empty(self)


    def toString(self):
        """
        toString(RelAbsVector self) -> string


        Returns a string representation of this object

        """
        return _libsbml.RelAbsVector_toString(self)


    def erase(self):
        """
        erase(RelAbsVector self)


        resets this element by setting the two coordinates to '0.0'

        """
        return _libsbml.RelAbsVector_erase(self)

RelAbsVector_swigregister = _libsbml.RelAbsVector_swigregister
RelAbsVector_swigregister(RelAbsVector)

class Ellipse(GraphicalPrimitive2D):
    """

    [SBML 'render' package]

    Graphical representation of an ellipse.

    The Ellipse class is derived from GraphicalPrimitive2D, so it inherits
    all the attributes and methods of the latter.  This means ellipses can
    have a transformation, a stroke and a stroke with to draw the edge as
    well as a fill style and fill style related settings.  Besides those
    inherited attributes, an ellipse if defined by its center point which
    can be specified as a combination of absolute and relative values and
    its radii for the two axes. The radii can also be specified in terms
    absolute and/or relative values.

    """

    __swig_setmethods__ = {}
    for _s in [GraphicalPrimitive2D]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Ellipse, name, value)
    __swig_getmethods__ = {}
    for _s in [GraphicalPrimitive2D]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Ellipse, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(Ellipse self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> Ellipse
        __init__(Ellipse self, unsigned int level, unsigned int version) -> Ellipse
        __init__(Ellipse self, unsigned int level) -> Ellipse
        __init__(Ellipse self) -> Ellipse
        __init__(Ellipse self, RenderPkgNamespaces renderns) -> Ellipse
        __init__(Ellipse self, XMLNode node, unsigned int l2version=4) -> Ellipse
        __init__(Ellipse self, XMLNode node) -> Ellipse
        __init__(Ellipse self, RenderPkgNamespaces renderns, string id) -> Ellipse
        __init__(Ellipse self, RenderPkgNamespaces renderns, RelAbsVector cx, RelAbsVector cy, RelAbsVector r) -> Ellipse
        __init__(Ellipse self, RenderPkgNamespaces renderns, RelAbsVector cx, RelAbsVector cy, RelAbsVector rx, RelAbsVector ry) -> Ellipse
        __init__(Ellipse self, RenderPkgNamespaces renderns, RelAbsVector cx, RelAbsVector cy, RelAbsVector cz, RelAbsVector rx, RelAbsVector ry) -> Ellipse
        __init__(Ellipse self, RenderPkgNamespaces renderns, string id, RelAbsVector cx, RelAbsVector cy, RelAbsVector r) -> Ellipse
        __init__(Ellipse self, RenderPkgNamespaces renderns, string id, RelAbsVector cx, RelAbsVector cy, RelAbsVector rx, RelAbsVector ry) -> Ellipse
        __init__(Ellipse self, RenderPkgNamespaces renderns, string id, RelAbsVector cx, RelAbsVector cy, RelAbsVector cz, RelAbsVector rx, RelAbsVector ry) -> Ellipse
        __init__(Ellipse self, Ellipse orig) -> Ellipse


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            Ellipse(long level = RenderExtension.getDefaultLevel(), long
        version = RenderExtension.getDefaultVersion(), long pkgVersion =
        RenderExtension.getDefaultPackageVersion())

        Creates a new Ellipse using the given SBML Level, Version and
        "render" package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        Ellipse.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this Ellipse.

        Parameter 'pkgVersion' is a long integer, the SBML Render Version to
        assign to this Ellipse.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            Ellipse(RenderPkgNamespaces renderns, string id,RelAbsVector
        cx,RelAbsVector cy,RelAbsVector rx,RelAbsVector ry)

        Constructor with id, 2D center and radii. instantiates a new ellipse
        object with the given 'id', center and radii.

        Parameter 'renderns' is SBMLNamespaces object for the SBML Render
        package Parameter 'id' is id for the ellipse Parameter 'cx' is x value
        of the center point  Parameter 'cy' is y value of the center point
        Parameter 'rx' is radius along the x axis Parameter 'ry' is radius
        along the y axis

        WARNING:

        This constructor is deprecated. The new libSBML API uses constructors
        that either take the SBML Level and Version, or take an SBMLNamespaces
        object.

        ______________________________________________________________________
        Method variant with the following signature:

            Ellipse(RenderPkgNamespaces renderns)

        Creates a new Ellipse using the given RenderPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'renderns' is the RenderPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        ______________________________________________________________________
        Method variant with the following signature:

            Ellipse(Ellipse orig)

        Copy constructor for Ellipse.

        Parameter 'orig' is the Ellipse instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            Ellipse(XMLNode node, long l2version=4)

        Creates a new RadialGradient object from the given XMLNode object.

        The XMLNode object must contain a valid XML representation of a
        RadialGradient object as defined in the render extension
        specification. This method is normally called when render information
        is read from a file and should normally not have to be called
        explicitly.

        Parameter 'node' is the XMLNode object reference that describes the
        RadialGradient object to be instantiated. Parameter 'l2version' is an
        integer indicating the version of SBML Level 2

        WARNING:

        This constructor is deprecated. The new libSBML API uses constructors
        that either take the SBML Level and Version, or take an SBMLNamespaces
        object.

        ______________________________________________________________________
        Method variant with the following signature:

            Ellipse(RenderPkgNamespaces renderns, string id)

        Instantiates a new ellipse object with the center set to 0,0,0 and the
        radii also set to 0. The id is set to the given string.

        Parameter 'renderns' is SBMLNamespaces object for the SBML Render
        package Parameter 'id' is the id of the ellipse.

        WARNING:

        This constructor is deprecated. The new libSBML API uses constructors
        that either take the SBML Level and Version, or take an SBMLNamespaces
        object.

        ______________________________________________________________________
        Method variant with the following signature:

            Ellipse(RenderPkgNamespaces renderns, RelAbsVector
        cx,RelAbsVector cy,RelAbsVector r)

        Constructor with 2D center and radius. instantiates a new ellipse
        object with the center. The z coordinate of the center is set to 0.
        The id is unset and both radii are set to the given radius.

        Parameter 'renderns' is SBMLNamespaces object for the SBML Render
        package Parameter 'cx' is x value of the center point  Parameter 'cy'
        is y value of the center point  Parameter 'r' is radius along both
        axis

        WARNING:

        This constructor is deprecated. The new libSBML API uses constructors
        that either take the SBML Level and Version, or take an SBMLNamespaces
        object.

        ______________________________________________________________________
        Method variant with the following signature:

            Ellipse(RenderPkgNamespaces renderns, RelAbsVector
        cx,RelAbsVector cy,RelAbsVector cz,RelAbsVector rx,RelAbsVector ry)

        Constructor with 3D center and radii. instantiates a new ellipse
        object with the center and radii. The id is unset.

        Parameter 'renderns' is SBMLNamespaces object for the SBML Render
        package Parameter 'cx' is x value of the center point  Parameter 'cy'
        is y value of the center point  Parameter 'cz' is z value of the
        center point  Parameter 'rx' is radius along the x axis Parameter 'ry'
        is radius along the y axis

        WARNING:

        This constructor is deprecated. The new libSBML API uses constructors
        that either take the SBML Level and Version, or take an SBMLNamespaces
        object.

        ______________________________________________________________________
        Method variant with the following signature:

            Ellipse(RenderPkgNamespaces renderns, RelAbsVector
        cx,RelAbsVector cy,RelAbsVector rx,RelAbsVector ry)

        Constructor with 2D center and radii.

        WARNING:

        This constructor is deprecated. The new libSBML API uses constructors
        that either take the SBML Level and Version, or take an SBMLNamespaces
        object.

        ______________________________________________________________________
        Method variant with the following signature:

            Ellipse(RenderPkgNamespaces renderns, string id,RelAbsVector
        cx,RelAbsVector cy,RelAbsVector cz,RelAbsVector rx,RelAbsVector ry)

        Constructor with id, 3D center and radii. instantiates a new ellipse
        object with the given 'id', center and radii.

        Parameter 'renderns' is SBMLNamespaces object for the SBML Render
        package Parameter 'id' is id for the ellipse Parameter 'cx' is x value
        of the center point  Parameter 'cy' is y value of the center point
        Parameter 'cz' is z value of the center point  Parameter 'rx' is
        radius along the x axis Parameter 'ry' is radius along the y axis

        WARNING:

        This constructor is deprecated. The new libSBML API uses constructors
        that either take the SBML Level and Version, or take an SBMLNamespaces
        object.

        ______________________________________________________________________
        Method variant with the following signature:

            Ellipse(RenderPkgNamespaces renderns, string id,RelAbsVector
        cx,RelAbsVector cy,RelAbsVector r)

        Constructor with id, 2D center and radius. instantiates a new ellipse
        object with the given 'id' and center. Both radii are set to the given
        radius r. This actually yields a circle.

        Parameter 'renderns' is SBMLNamespaces object for the SBML Render
        package Parameter 'id' is id for the ellipse Parameter 'cx' is x value
        of the center point  Parameter 'cy' is y value of the center point
        Parameter 'r' is radius along both axis

        WARNING:

        This constructor is deprecated. The new libSBML API uses constructors
        that either take the SBML Level and Version, or take an SBMLNamespaces
        object.

        """
        this = _libsbml.new_Ellipse(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(Ellipse self) -> Ellipse


        Creates and returns a deep copy of this Ellipse object.

        Returns a (deep) copy of this Ellipse object.

        """
        return _libsbml.Ellipse_clone(self)

    __swig_destroy__ = _libsbml.delete_Ellipse
    __del__ = lambda self: None

    def getRatio(self):
        """
        getRatio(Ellipse self) -> double


        Returns the value of the 'ratio' attribute of this Ellipse.

        Returns the value of the 'ratio' attribute of this Ellipse as a
        double.

        """
        return _libsbml.Ellipse_getRatio(self)


    def isSetRatio(self):
        """
        isSetRatio(Ellipse self) -> bool


        Predicate returning 'True' if this Ellipse's 'ratio' attribute is set.

        Returns 'True' if this Ellipse's 'ratio' attribute has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.Ellipse_isSetRatio(self)


    def setRatio(self, ratio):
        """
        setRatio(Ellipse self, double ratio) -> int


        Sets the value of the 'ratio' attribute of this Ellipse.

        Parameter 'ratio' is double value of the 'ratio' attribute to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Ellipse_setRatio(self, ratio)


    def unsetRatio(self):
        """
        unsetRatio(Ellipse self) -> int


        Unsets the value of the 'ratio' attribute of this Ellipse.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Ellipse_unsetRatio(self)


    def getCX(self, *args):
        """
        getCX(Ellipse self) -> RelAbsVector
        getCX(Ellipse self) -> RelAbsVector


        Returns the x coordinate for the center point as a  reference.

        Returns reference to the x coordinate of the center point.

        """
        return _libsbml.Ellipse_getCX(self, *args)


    def getCY(self, *args):
        """
        getCY(Ellipse self) -> RelAbsVector
        getCY(Ellipse self) -> RelAbsVector


        Returns the y coordinate for the center point as a  reference.

        Returns reference to the y coordinate of the center point.

        """
        return _libsbml.Ellipse_getCY(self, *args)


    def getCZ(self, *args):
        """
        getCZ(Ellipse self) -> RelAbsVector
        getCZ(Ellipse self) -> RelAbsVector


        Returns the z coordinate for the center point as a  reference.

        Returns reference to the z coordinate of the center point.

        """
        return _libsbml.Ellipse_getCZ(self, *args)


    def getRX(self, *args):
        """
        getRX(Ellipse self) -> RelAbsVector
        getRX(Ellipse self) -> RelAbsVector


        Returns the radius along the x axis as a  reference.

        Returns reference to the radius along the x axis

        """
        return _libsbml.Ellipse_getRX(self, *args)


    def getRY(self, *args):
        """
        getRY(Ellipse self) -> RelAbsVector
        getRY(Ellipse self) -> RelAbsVector


        Returns the radius along the y axis as a  reference.

        Returns reference to the radius along the y axis

        """
        return _libsbml.Ellipse_getRY(self, *args)


    def isSetCX(self):
        """
        isSetCX(Ellipse self) -> bool


        Predicate returning 'True' if this Ellipse's 'cx' element is set.

        Returns 'True' if this Ellipse's 'cx' element has been set, otherwise
        'False' is returned.

        """
        return _libsbml.Ellipse_isSetCX(self)


    def isSetCY(self):
        """
        isSetCY(Ellipse self) -> bool


        Predicate returning 'True' if this Ellipse's 'cy' element is set.

        Returns 'True' if this Ellipse's 'cy' element has been set, otherwise
        'False' is returned.

        """
        return _libsbml.Ellipse_isSetCY(self)


    def isSetCZ(self):
        """
        isSetCZ(Ellipse self) -> bool


        Predicate returning 'True' if this Ellipse's 'cz' element is set.

        Returns 'True' if this Ellipse's 'cz' element has been set, otherwise
        'False' is returned.

        """
        return _libsbml.Ellipse_isSetCZ(self)


    def isSetRX(self):
        """
        isSetRX(Ellipse self) -> bool


        Predicate returning 'True' if this Ellipse's 'rx' element is set.

        Returns 'True' if this Ellipse's 'rx' element has been set, otherwise
        'False' is returned.

        """
        return _libsbml.Ellipse_isSetRX(self)


    def isSetRY(self):
        """
        isSetRY(Ellipse self) -> bool


        Predicate returning 'True' if this Ellipse's 'ry' element is set.

        Returns 'True' if this Ellipse's 'ry' element has been set, otherwise
        'False' is returned.

        """
        return _libsbml.Ellipse_isSetRY(self)


    def setCX(self, cx):
        """
        setCX(Ellipse self, RelAbsVector cx) -> int


        Sets the x coordinates for the center point.

        Parameter 'cx' is x value of the center point

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.Ellipse_setCX(self, cx)


    def setCY(self, cy):
        """
        setCY(Ellipse self, RelAbsVector cy) -> int


        Sets the y coordinates for the center point.

        Parameter 'cy' is y value of the center point

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.Ellipse_setCY(self, cy)


    def setCZ(self, cz):
        """
        setCZ(Ellipse self, RelAbsVector cz) -> int


        Sets the z coordinates for the center point.

        Parameter 'cz' is z value of the center point

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.Ellipse_setCZ(self, cz)


    def setRX(self, rx):
        """
        setRX(Ellipse self, RelAbsVector rx) -> int


        Sets the radius along the x axis

        Parameter 'rx' is radius along the x axis

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.Ellipse_setRX(self, rx)


    def setRY(self, ry):
        """
        setRY(Ellipse self, RelAbsVector ry) -> int


        Sets the radius along the y axis

        Parameter 'ry' is radius along the y axis

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.Ellipse_setRY(self, ry)


    def setCenter2D(self, cx, cy):
        """
        setCenter2D(Ellipse self, RelAbsVector cx, RelAbsVector cy)


        Sets the 2D coordinates for the center point. The z coodintate is set
        to 50%

        Parameter 'cx' is x value of the center point  Parameter 'cy' is y
        value of the center point

        """
        return _libsbml.Ellipse_setCenter2D(self, cx, cy)


    def setCenter3D(self, cx, cy, cz):
        """
        setCenter3D(Ellipse self, RelAbsVector cx, RelAbsVector cy, RelAbsVector cz)


        Sets the 3D coordinates for the center point.

        Parameter 'cx' is x value of the center point  Parameter 'cy' is y
        value of the center point  Parameter 'cz' is z value of the center
        point

        """
        return _libsbml.Ellipse_setCenter3D(self, cx, cy, cz)


    def setRadii(self, rx, ry):
        """
        setRadii(Ellipse self, RelAbsVector rx, RelAbsVector ry)


        Sets the radii of the ellipse

        Parameter 'rx' is radius along the x axis Parameter 'ry' is radius
        along the y axis

        """
        return _libsbml.Ellipse_setRadii(self, rx, ry)


    def unsetCX(self):
        """
        unsetCX(Ellipse self) -> int


        Unsets the value of the 'cx' element of this Ellipse.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.Ellipse_unsetCX(self)


    def unsetCY(self):
        """
        unsetCY(Ellipse self) -> int


        Unsets the value of the 'cy' element of this Ellipse.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.Ellipse_unsetCY(self)


    def unsetCZ(self):
        """
        unsetCZ(Ellipse self) -> int


        Unsets the value of the 'cz' element of this Ellipse.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.Ellipse_unsetCZ(self)


    def unsetRX(self):
        """
        unsetRX(Ellipse self) -> int


        Unsets the value of the 'rx' element of this Ellipse.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.Ellipse_unsetRX(self)


    def unsetRY(self):
        """
        unsetRY(Ellipse self) -> int


        Unsets the value of the 'ry' element of this Ellipse.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.Ellipse_unsetRY(self)


    def getElementName(self):
        """
        getElementName(Ellipse self) -> string


        Returns the XML element name of this Ellipse object.

        For Ellipse, the XML element name is always ''ellipse'.'

        Returns the name of this element, i.e. ''ellipse'.'

        """
        return _libsbml.Ellipse_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(Ellipse self) -> int


        Returns the libSBML type code for this Ellipse object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_RENDER_ELLIPSE.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.Ellipse_getTypeCode(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(Ellipse self) -> bool


        Predicate returning 'True' if all the required attributes for this
        Ellipse object have been set.

        Returns 'True' to indicate that all the required attributes of this
        Ellipse have been set, otherwise 'False' is returned.

        Note: The required attributes for the Ellipse object are:

        * 'cx'

        * 'cy'

        * 'rx'

        """
        return _libsbml.Ellipse_hasRequiredAttributes(self)


    def toXML(self):
        """
        toXML(Ellipse self) -> XMLNode


        Creates an XMLNode object from this Ellipse object.

        Returns the XMLNode with the XML representation for the  Ellipse
        object.

        """
        return _libsbml.Ellipse_toXML(self)

Ellipse_swigregister = _libsbml.Ellipse_swigregister
Ellipse_swigregister(Ellipse)

class GlobalRenderInformation(RenderInformationBase):
    """

    [SBML 'render' package]

    Render information stored in a ListOfLayouts.

    GlobalRenderInformation is one of the subclasses of
    RenderInformationBase. A global render information object contains
    color definitions, gradient definitions and line endings as defined in
    RenderInformationBase. Additionally it has a list of global styles
    which specifies type and role based render information.  This class of
    objects cannot specify id-based render information because it does not
    belong to a certain layout but it belongs to all layouts.
    GlobalRenderInformation can be applied to all layouts.

    """

    __swig_setmethods__ = {}
    for _s in [RenderInformationBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GlobalRenderInformation, name, value)
    __swig_getmethods__ = {}
    for _s in [RenderInformationBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, GlobalRenderInformation, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(GlobalRenderInformation self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> GlobalRenderInformation
        __init__(GlobalRenderInformation self, unsigned int level, unsigned int version) -> GlobalRenderInformation
        __init__(GlobalRenderInformation self, unsigned int level) -> GlobalRenderInformation
        __init__(GlobalRenderInformation self) -> GlobalRenderInformation
        __init__(GlobalRenderInformation self, RenderPkgNamespaces renderns) -> GlobalRenderInformation
        __init__(GlobalRenderInformation self, RenderPkgNamespaces renderns, string id) -> GlobalRenderInformation
        __init__(GlobalRenderInformation self, GlobalRenderInformation orig) -> GlobalRenderInformation


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            GlobalRenderInformation(RenderPkgNamespaces renderns, string
        id)

        Constructor which creates a GlobalRenderInformation with the given
        'id' and all lists empty.

        Parameter 'renderns' is the SBMLNamespaces object for the SBML
        'render' package Parameter 'id' is the new id for the
        GlobalRenderInformation.

        WARNING:

        This constructor is deprecated. The new libSBML API uses constructors
        that either take the SBML Level and Version, or take an SBMLNamespaces
        object.

        ______________________________________________________________________
        Method variant with the following signature:

            GlobalRenderInformation( long level =
        RenderExtension.getDefaultLevel(), long version =
        RenderExtension.getDefaultVersion(), long pkgVersion =
        RenderExtension.getDefaultPackageVersion())

        Creates a new GlobalRenderInformation using the given SBML Level,
        Version and "render" package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        GlobalRenderInformation.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this GlobalRenderInformation.

        Parameter 'pkgVersion' is a long integer, the SBML Render Version to
        assign to this GlobalRenderInformation.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            GlobalRenderInformation(RenderPkgNamespaces renderns)

        Creates a new GlobalRenderInformation using the given
        RenderPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'renderns' is the RenderPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        ______________________________________________________________________
        Method variant with the following signature:

            GlobalRenderInformation(GlobalRenderInformation orig)

        Copy constructor for GlobalRenderInformation.

        Parameter 'orig' is the GlobalRenderInformation instance to copy.

        """
        this = _libsbml.new_GlobalRenderInformation(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(GlobalRenderInformation self) -> GlobalRenderInformation


        Creates and returns a deep copy of this GlobalRenderInformation
        object.

        Returns a (deep) copy of this GlobalRenderInformation object.

        """
        return _libsbml.GlobalRenderInformation_clone(self)

    __swig_destroy__ = _libsbml.delete_GlobalRenderInformation
    __del__ = lambda self: None

    def getListOfGlobalStyles(self, *args):
        """
        getListOfGlobalStyles(GlobalRenderInformation self) -> ListOfGlobalStyles
        getListOfGlobalStyles(GlobalRenderInformation self) -> ListOfGlobalStyles


        Returns the ListOfGlobalStyles from this GlobalRenderInformation.

        Returns the ListOfGlobalStyles from this GlobalRenderInformation.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addGlobalStyle(), createGlobalStyle(), getGlobalStyle(),
        getGlobalStyle(), getNumGlobalStyles(), removeGlobalStyle(),
        removeGlobalStyle().

        """
        return _libsbml.GlobalRenderInformation_getListOfGlobalStyles(self, *args)


    def getListOfStyles(self, *args):
        """
        getListOfStyles(GlobalRenderInformation self) -> ListOfGlobalStyles
        getListOfStyles(GlobalRenderInformation self) -> ListOfGlobalStyles


        Returns the ListOfGlobalStyles from this GlobalRenderInformation.

        Returns the ListOfGlobalStyles from this GlobalRenderInformation.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addStyle(), createStyle(), getStyle(), getStyle(),
        getNumStyles(), removeGlobalStyle(), removeGlobalStyle().

        """
        return _libsbml.GlobalRenderInformation_getListOfStyles(self, *args)


    def getGlobalStyle(self, *args):
        """
        getGlobalStyle(GlobalRenderInformation self, unsigned int n) -> GlobalStyle
        getGlobalStyle(GlobalRenderInformation self, unsigned int n) -> GlobalStyle
        getGlobalStyle(GlobalRenderInformation self, string id) -> GlobalStyle
        getGlobalStyle(GlobalRenderInformation self, string id) -> GlobalStyle


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getGlobalStyle(long n)

        Get a GlobalStyle from the GlobalRenderInformation.

        Parameter 'n' is a long integer representing the index of the
        GlobalStyle to retrieve.

        Returns the nth GlobalStyle in the ListOfGlobalStyles within this
        GlobalRenderInformation or 'None' if no such object exists.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addGlobalStyle(), createGlobalStyle(), getGlobalStyle(),
        getNumGlobalStyles(), removeGlobalStyle(), removeGlobalStyle().

        ______________________________________________________________________
        Method variant with the following signature:

            getGlobalStyle(string id)

        Get a GlobalStyle from the GlobalRenderInformation.

        Parameter 'id' is a string representing the identifier of the
        ColorDefinition to remove.

        Returns the GlobalStyle in this GlobalRenderInformation based on the
        identifier or None if no such GlobalStyle exists.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addGlobalStyle(), createGlobalStyle(), getGlobalStyle(),
        getNumGlobalStyles(), removeGlobalStyle(), removeGlobalStyle().

        """
        return _libsbml.GlobalRenderInformation_getGlobalStyle(self, *args)


    def getStyle(self, *args):
        """
        getStyle(GlobalRenderInformation self, unsigned int n) -> GlobalStyle
        getStyle(GlobalRenderInformation self, unsigned int n) -> GlobalStyle
        getStyle(GlobalRenderInformation self, string id) -> GlobalStyle
        getStyle(GlobalRenderInformation self, string id) -> GlobalStyle


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getStyle(long n)

        Get a GlobalStyle from the GlobalRenderInformation.

        Parameter 'n' is a long integer representing the index of the
        GlobalStyle to retrieve.

        Returns the nth GlobalStyle in the ListOfGlobalStyles within this
        GlobalRenderInformation. If the index 'n' is invalid, 'None' is
        returned.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addStyle(), createStyle(), getStyle(), getNumStyles(),
        removeGlobalStyle(), removeGlobalStyle().

        ______________________________________________________________________
        Method variant with the following signature:

            getStyle(string id)

        Get a GlobalStyle from the GlobalRenderInformation.

        Parameter 'id' is a string representing the identifier of the
        ColorDefinition to remove.

        Returns the GlobalStyle in this GlobalRenderInformation based on the
        identifier or None if no such GlobalStyle exists.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addStyle(), createStyle(), getStyle(), getNumStyles(),
        removeGlobalStyle(), removeGlobalStyle().

        """
        return _libsbml.GlobalRenderInformation_getStyle(self, *args)


    def addGlobalStyle(self, gs):
        """
        addGlobalStyle(GlobalRenderInformation self, GlobalStyle gs) -> int


        Adds a copy of the given GlobalStyle to this GlobalRenderInformation.

        Parameter 'gs' is the GlobalStyle object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_PKG_VERSION_MISMATCH

        * LIBSBML_DUPLICATE_OBJECT_ID

        Note: This method should be used with some caution.  The fact that
        this method copies the object passed to it means that the caller will
        be left holding a physically different object instance than the one
        contained inside this object.  Changes made to the original object
        instance (such as resetting attribute values) will not affect the
        instance in this object.  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 other methods on this class
        (particularly a corresponding method whose name begins with the word
        create) for alternatives that do not lead to these issues.

        See also createGlobalStyle(), getGlobalStyle(), getGlobalStyle(),
        getNumGlobalStyles(), removeGlobalStyle(), removeGlobalStyle().

        """
        return _libsbml.GlobalRenderInformation_addGlobalStyle(self, gs)


    def addStyle(self, gs):
        """
        addStyle(GlobalRenderInformation self, GlobalStyle gs) -> int


        Adds a copy of the given GlobalStyle to this GlobalRenderInformation.

        Parameter 'gs' is the GlobalStyle object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_PKG_VERSION_MISMATCH

        * LIBSBML_DUPLICATE_OBJECT_ID

        Note: This method should be used with some caution.  The fact that
        this method copies the object passed to it means that the caller will
        be left holding a physically different object instance than the one
        contained inside this object.  Changes made to the original object
        instance (such as resetting attribute values) will not affect the
        instance in this object.  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 other methods on this class
        (particularly a corresponding method whose name begins with the word
        create) for alternatives that do not lead to these issues.

        See also createStyle(), getStyle(), getStyle(), getNumStyles(),
        removeGlobalStyle(), removeGlobalStyle().

        """
        return _libsbml.GlobalRenderInformation_addStyle(self, gs)


    def getNumGlobalStyles(self):
        """
        getNumGlobalStyles(GlobalRenderInformation self) -> unsigned int


        Get the number of GlobalStyle objects in this GlobalRenderInformation.

        Returns the number of GlobalStyle objects in this
        GlobalRenderInformation.

        See also addGlobalStyle(), createGlobalStyle(), getGlobalStyle(),
        getGlobalStyle(), removeGlobalStyle(), removeGlobalStyle().

        """
        return _libsbml.GlobalRenderInformation_getNumGlobalStyles(self)


    def getNumStyles(self):
        """
        getNumStyles(GlobalRenderInformation self) -> unsigned int


        Get the number of GlobalStyle objects in this GlobalRenderInformation.

        Returns the number of GlobalStyle objects in this
        GlobalRenderInformation.

        See also addStyle(), createStyle(), getStyle(), getStyle(),
        removeGlobalStyle(), removeGlobalStyle().

        """
        return _libsbml.GlobalRenderInformation_getNumStyles(self)


    def createGlobalStyle(self):
        """
        createGlobalStyle(GlobalRenderInformation self) -> GlobalStyle


        Creates a new GlobalStyle object, adds it to this
        GlobalRenderInformation object and returns the GlobalStyle object
        created.

        Returns a new GlobalStyle object instance.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addGlobalStyle(), getGlobalStyle(), getGlobalStyle(),
        getNumGlobalStyles(), removeGlobalStyle(), removeGlobalStyle().

        """
        return _libsbml.GlobalRenderInformation_createGlobalStyle(self)


    def createStyle(self, id):
        """
        createStyle(GlobalRenderInformation self, string id) -> GlobalStyle


        Creates a new GlobalStyle object with the given id, adds it to this
        GlobalRenderInformation object and returns the GlobalStyle object
        created.

        Returns a new GlobalStyle object instance.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addStyle(), getStyle(), getStyle(), getNumStyles(),
        removeGlobalStyle(), removeGlobalStyle().

        """
        return _libsbml.GlobalRenderInformation_createStyle(self, id)


    def removeGlobalStyle(self, *args):
        """
        removeGlobalStyle(GlobalRenderInformation self, unsigned int n) -> GlobalStyle
        removeGlobalStyle(GlobalRenderInformation self, string sid) -> GlobalStyle


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeGlobalStyle(long n)

        Removes the nth GlobalStyle from this GlobalRenderInformation and
        returns a pointer to it.

        Parameter 'n' is a long integer representing the index of the
        GlobalStyle to remove.

        Returns a pointer to the nth GlobalStyle in this
        GlobalRenderInformation.

        WARNING:

        The pointer that is returned by this function is owned by the caller,
        who is responsible for deleting it.  Any changes made to the element
        will not be reflected in any resulting SBML document unless the
        element is added to an SBML Document.  Even in this case, the
        element's deletion is still the responsibility of the caller with two
        exceptions: if it is used as the 'disownedItem' in the
        ListOf.appendAndOwn() or ListOf.insertAndOwn()  functions.  All other
        functions in libsbml add a copy of the element, and do not transfer
        ownership of the pointer.

        See also addGlobalStyle(), createGlobalStyle(), getGlobalStyle(),
        getGlobalStyle(), getNumGlobalStyles(), removeGlobalStyle().

        ______________________________________________________________________
        Method variant with the following signature:

            removeGlobalStyle(string sid)

        Removes the GlobalStyle with the given id from this
        GlobalRenderInformation  and returns a pointer to it.

        Parameter 'sid' is the id of the GlobalStyle to remove.

        Returns a pointer to the nth GlobalStyle in this
        GlobalRenderInformation.

        WARNING:

        The pointer that is returned by this function is owned by the caller,
        who is responsible for deleting it.  Any changes made to the element
        will not be reflected in any resulting SBML document unless the
        element is added to an SBML Document.  Even in this case, the
        element's deletion is still the responsibility of the caller with two
        exceptions: if it is used as the 'disownedItem' in the
        ListOf.appendAndOwn() or ListOf.insertAndOwn()  functions.  All other
        functions in libsbml add a copy of the element, and do not transfer
        ownership of the pointer.

        See also addGlobalStyle(), createGlobalStyle(), getGlobalStyle(),
        getGlobalStyle(), getNumGlobalStyles(), removeGlobalStyle().

        """
        return _libsbml.GlobalRenderInformation_removeGlobalStyle(self, *args)


    def removeStyle(self, n):
        """
        removeStyle(GlobalRenderInformation self, unsigned int n) -> GlobalStyle


        Removes the nth GlobalStyle from this GlobalRenderInformation and
        returns a pointer to it.

        Parameter 'n' is a long integer representing the index of the
        GlobalStyle to remove.

        Returns a pointer to the nth GlobalStyle in this
        GlobalRenderInformation.

        WARNING:

        The pointer that is returned by this function is owned by the caller,
        who is responsible for deleting it.  Any changes made to the element
        will not be reflected in any resulting SBML document unless the
        element is added to an SBML Document.  Even in this case, the
        element's deletion is still the responsibility of the caller with two
        exceptions: if it is used as the 'disownedItem' in the
        ListOf.appendAndOwn() or ListOf.insertAndOwn()  functions.  All other
        functions in libsbml add a copy of the element, and do not transfer
        ownership of the pointer.

        See also addStyle(), createStyle(), getStyle(), getStyle(),
        getNumStyles(), removeGlobalStyle(), removeGlobalStyle().

        """
        return _libsbml.GlobalRenderInformation_removeStyle(self, n)


    def getElementName(self):
        """
        getElementName(GlobalRenderInformation self) -> string


        Returns the XML element name of this GlobalRenderInformation object.

        For GlobalRenderInformation, the XML element name is always
        ''renderInformation'.'

        Returns the name of this element, i.e. ''renderInformation'.'

        """
        return _libsbml.GlobalRenderInformation_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(GlobalRenderInformation self) -> int


        Returns the libSBML type code for this GlobalRenderInformation object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object:
        SBML_RENDER_GLOBALRENDERINFORMATION.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.GlobalRenderInformation_getTypeCode(self)


    def connectToChild(self):
        """
        connectToChild(GlobalRenderInformation self)


        Internal implementation method.

        """
        return _libsbml.GlobalRenderInformation_connectToChild(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(GlobalRenderInformation self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.GlobalRenderInformation_enablePackageInternal(self, pkgURI, pkgPrefix, flag)


    def getElementBySId(self, id):
        """
        getElementBySId(GlobalRenderInformation self, string id) -> SBase


        Returns the first child element that has the given 'id' in the model-
        wide SId namespace, or 'None' if no such object is found.

        Parameter 'id' is a string representing the id attribute of the object
        to retrieve.

        Returns a pointer to the SBase element with the given 'id'. If no such
        object is found, this method returns 'None.'

        """
        return _libsbml.GlobalRenderInformation_getElementBySId(self, id)


    def getElementByMetaId(self, metaid):
        """
        getElementByMetaId(GlobalRenderInformation self, string metaid) -> SBase


        Returns the first child element that has the given 'metaid', or 'None'
        if no such object is found.

        Parameter 'metaid' is a string representing the metaid attribute of
        the object to retrieve.

        Returns a pointer to the SBase element with the given 'metaid'. If no
        such object is found this method returns 'None.'

        """
        return _libsbml.GlobalRenderInformation_getElementByMetaId(self, metaid)


    def parseXML(self, node):
        """
        parseXML(GlobalRenderInformation self, XMLNode node)


        Parses the xml information in the given node and sets the attributes.
        This method should never be called by the user. It is only used to
        read render  information from annotations.

        Parameter 'node' is the XMLNode object reference that describes the
        GlobalRenderInformation object to be instantiated.

        """
        return _libsbml.GlobalRenderInformation_parseXML(self, node)


    def toXML(self):
        """
        toXML(GlobalRenderInformation self) -> XMLNode


        Creates an XMLNode object from this GlobalRenderInformation object.

        Returns the XMLNode with the XML representation for the
        GlobalRenderInformation object.

        """
        return _libsbml.GlobalRenderInformation_toXML(self)

GlobalRenderInformation_swigregister = _libsbml.GlobalRenderInformation_swigregister
GlobalRenderInformation_swigregister(GlobalRenderInformation)

class GlobalStyle(Style):
    """

    [SBML 'render' package]

    A style that can be associated with a layout.

    Global styles are the style information objects used in
    GlobalRenderInformation.  Global styles can be associated with layout
    objects by role and type, but not by identifier; in other respects,
    global styles and local styles are equivalent.

    Since GlobalStyle is derived from Styles, it inherits all of the
    methods and attributes from Style.

    See also GlobalRenderInformation, Style.

    """

    __swig_setmethods__ = {}
    for _s in [Style]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GlobalStyle, name, value)
    __swig_getmethods__ = {}
    for _s in [Style]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, GlobalStyle, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(GlobalStyle self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> GlobalStyle
        __init__(GlobalStyle self, unsigned int level, unsigned int version) -> GlobalStyle
        __init__(GlobalStyle self, unsigned int level) -> GlobalStyle
        __init__(GlobalStyle self) -> GlobalStyle
        __init__(GlobalStyle self, RenderPkgNamespaces renderns) -> GlobalStyle
        __init__(GlobalStyle self, XMLNode node, unsigned int l2version=4) -> GlobalStyle
        __init__(GlobalStyle self, XMLNode node) -> GlobalStyle
        __init__(GlobalStyle self, RenderPkgNamespaces renderns, string id) -> GlobalStyle
        __init__(GlobalStyle self, GlobalStyle orig) -> GlobalStyle


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            GlobalStyle(long level = RenderExtension.getDefaultLevel(),
        long version = RenderExtension.getDefaultVersion(), long pkgVersion =
        RenderExtension.getDefaultPackageVersion())

        Creates a new GlobalStyle using the given SBML Level, Version and
        "render" package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        GlobalStyle.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this GlobalStyle.

        Parameter 'pkgVersion' is a long integer, the SBML Render Version to
        assign to this GlobalStyle.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            GlobalStyle(RenderPkgNamespaces renderns, string id)

        Constructor which creates a GlobalStyle with the given 'id' and all
        lists empty.

        Parameter 'renderns' is the SBMLNamespaces object for the SBML
        'render' package Parameter 'id' is the new id for the GlobalStyle.

        WARNING:

        This constructor is deprecated. The new libSBML API uses constructors
        that either take the SBML Level and Version, or take an SBMLNamespaces
        object.

        ______________________________________________________________________
        Method variant with the following signature:

            GlobalStyle(XMLNode node, long l2version=4)

        Creates a new GlobalStyle object from the given XMLNode object. The
        XMLNode object has to contain a valid XML representation of a
        GlobalStyle object as defined in the render extension specification.
        This method is normally called when render information is read from a
        file and  should normally not have to be called explicitly.

        Parameter 'node' is the XMLNode object reference that describes the
        GlobalStyle object to be instantiated.

        Parameter 'l2version' is an integer indicating the version of SBML
        Level 2

        ______________________________________________________________________
        Method variant with the following signature:

            GlobalStyle(GlobalStyle orig)

        Copy constructor for GlobalStyle.

        Parameter 'orig' is the GlobalStyle instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            GlobalStyle(RenderPkgNamespaces renderns)

        Creates a new GlobalStyle using the given RenderPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'renderns' is the RenderPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_GlobalStyle(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(GlobalStyle self) -> GlobalStyle


        Creates and returns a deep copy of this GlobalStyle object.

        Returns a (deep) copy of this GlobalStyle object.

        """
        return _libsbml.GlobalStyle_clone(self)

    __swig_destroy__ = _libsbml.delete_GlobalStyle
    __del__ = lambda self: None

    def getElementName(self):
        """
        getElementName(GlobalStyle self) -> string


        Returns the XML element name of this GlobalStyle object.

        For GlobalStyle, the XML element name is always ''style'.'

        Returns the name of this element, i.e. ''style'.'

        """
        return _libsbml.GlobalStyle_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(GlobalStyle self) -> int


        Returns the libSBML type code for this GlobalStyle object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_RENDER_GLOBALSTYLE.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.GlobalStyle_getTypeCode(self)

GlobalStyle_swigregister = _libsbml.GlobalStyle_swigregister
GlobalStyle_swigregister(GlobalStyle)

class GradientStop(SBase):
    """

    [SBML 'render' package]

    A color at a certain location in a color gradient.

    The gradient stop concept was more or less taken from the
    corresponding concept in SVG.  A GradientStop object represents the
    color at a certain location in a linear or radial gradient.  Each
    gradient should contain two or more gradient stops which mark the
    edges of a region within this region color are interpolated based on
    the distance of the location to the edges of the region.

    A gradient stop has two attributes. The first attribute is an offset
    which determines the location for the gradient stop within the object
    the gradient is applied to.  The offset can either be an absolute
    value or a relative value or a combination of absolute and relative
    value.  For example, a value of '50%' for the offset means that the
    gradient stop is located at 50% of the gradient vector. For more
    information and examples, see the render extension specification or
    the SVG specification.

    The second attribute defines the color for the gradient stop. The
    color can either be defined be a color value string or by the id of a
    ColorDefinition object.

    See also ColorDefinition.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GradientStop, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, GradientStop, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(GradientStop self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> GradientStop
        __init__(GradientStop self, unsigned int level, unsigned int version) -> GradientStop
        __init__(GradientStop self, unsigned int level) -> GradientStop
        __init__(GradientStop self) -> GradientStop
        __init__(GradientStop self, RenderPkgNamespaces renderns) -> GradientStop
        __init__(GradientStop self, XMLNode node, unsigned int l2version=4) -> GradientStop
        __init__(GradientStop self, XMLNode node) -> GradientStop
        __init__(GradientStop self, GradientStop orig) -> GradientStop


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            GradientStop(long level = RenderExtension.getDefaultLevel(),
        long version = RenderExtension.getDefaultVersion(), long pkgVersion =
        RenderExtension.getDefaultPackageVersion())

        Creates a new GradientStop using the given SBML Level, Version and
        "render" package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        GradientStop.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this GradientStop.

        Parameter 'pkgVersion' is a long integer, the SBML Render Version to
        assign to this GradientStop.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            GradientStop(XMLNode node, long l2version=4)

        Creates a new GradientStop object from the given XMLNode object. The
        XMLNode object has to contain a valid XML representation of a
        GradientStop object as defined in the render extension specification.
        This method is normally called when render information is read from a
        file and  should normally not have to be called explicitly.

        Parameter 'node' is the XMLNode object reference that describes the
        GradientStop object to be instantiated.

        Parameter 'l2version' is an integer indicating the version of SBML
        Level 2

        ______________________________________________________________________
        Method variant with the following signature:

            GradientStop(RenderPkgNamespaces renderns)

        Creates a new GradientStop using the given RenderPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'renderns' is the RenderPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        ______________________________________________________________________
        Method variant with the following signature:

            GradientStop(GradientStop orig)

        Copy constructor for GradientStop.

        Parameter 'orig' is the GradientStop instance to copy.

        """
        this = _libsbml.new_GradientStop(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(GradientStop self) -> GradientStop


        Creates and returns a deep copy of this GradientStop object.

        Returns a (deep) copy of this GradientStop object.

        """
        return _libsbml.GradientStop_clone(self)

    __swig_destroy__ = _libsbml.delete_GradientStop
    __del__ = lambda self: None

    def getStopColor(self):
        """
        getStopColor(GradientStop self) -> string


        Returns the value of the 'stop-color' attribute of this GradientStop.

        Returns the value of the 'stop-color' attribute of this GradientStop
        as a string.

        """
        return _libsbml.GradientStop_getStopColor(self)


    def isSetStopColor(self):
        """
        isSetStopColor(GradientStop self) -> bool


        Predicate returning 'True' if this GradientStop's 'stop-color'
        attribute is set.

        Returns 'True' if this GradientStop's 'stop-color' attribute has been
        set, otherwise 'False' is returned.

        """
        return _libsbml.GradientStop_isSetStopColor(self)


    def setStopColor(self, stopColor):
        """
        setStopColor(GradientStop self, string stopColor) -> int


        Sets the value of the 'stop-color' attribute of this GradientStop.

        Parameter 'stopColor' is string& value of the 'stop-color' attribute
        to be set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        Calling this function with 'stopColor' = 'None' or an empty string is
        equivalent to calling unsetStopColor().

        """
        return _libsbml.GradientStop_setStopColor(self, stopColor)


    def unsetStopColor(self):
        """
        unsetStopColor(GradientStop self) -> int


        Unsets the value of the 'stop-color' attribute of this GradientStop.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.GradientStop_unsetStopColor(self)


    def getOffset(self, *args):
        """
        getOffset(GradientStop self) -> RelAbsVector
        getOffset(GradientStop self) -> RelAbsVector


        Returns the value of the 'offset' element of this GradientStop.

        Returns the value of the 'offset' element of this GradientStop as a
        RelAbsVector.

        """
        return _libsbml.GradientStop_getOffset(self, *args)


    def isSetOffset(self):
        """
        isSetOffset(GradientStop self) -> bool


        Predicate returning 'True' if this GradientStop's 'offset' element is
        set.

        Returns 'True' if this GradientStop's 'offset' element has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.GradientStop_isSetOffset(self)


    def setOffset(self, *args):
        """
        setOffset(GradientStop self, RelAbsVector offset) -> int
        setOffset(GradientStop self, double abs, double rel)
        setOffset(GradientStop self, string co)


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            setOffset(double abs,double rel)

        Sets the offset for the gradient stop.

        Parameter 'abs' is the absolute value of the offset.

        Parameter 'rel' is the relative value of the offset.

        ______________________________________________________________________
        Method variant with the following signature:

            setOffset(string co)

        Sets the offset to the value specified by the given string. The string
        has to represent a combination of an absolute  and relative value.
        Valid value string would e.g. be '45.0', '30%' or '10+5%'. If the
        value is a combination of both relative and  absolute value, the
        absolute value has to come before the relative value. Number can be
        given as integer values or floating point values and the two
        components can be combined by '+' or '-'. Depending on whethr the
        relative value should be added or subtracted from the  absolute value.
        If the given string is not valid, the offset will have an absolute
        and a relative value of NaN.

        Parameter 'co' is a string representing a valid offset value.

        ______________________________________________________________________
        Method variant with the following signature:

            setOffset(RelAbsVector offset)

        Sets the value of the 'offset' element of this GradientStop.

        Parameter 'offset' is RelAbsVector value of the 'offset' element to be
        set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.GradientStop_setOffset(self, *args)


    def unsetOffset(self):
        """
        unsetOffset(GradientStop self) -> int


        Unsets the value of the 'offset' element of this GradientStop.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.GradientStop_unsetOffset(self)


    def getElementName(self):
        """
        getElementName(GradientStop self) -> string


        Returns the XML element name of this GradientStop object.

        For GradientStop, the XML element name is always ''stop'.'

        Returns the name of this element, i.e. ''stop'.'

        """
        return _libsbml.GradientStop_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(GradientStop self) -> int


        Returns the libSBML type code for this GradientStop object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_RENDER_GRADIENT_STOP.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.GradientStop_getTypeCode(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(GradientStop self) -> bool


        Predicate returning 'True' if all the required attributes for this
        GradientStop object have been set.

        Returns 'True' to indicate that all the required attributes of this
        GradientStop have been set, otherwise 'False' is returned.

        Note: The required attributes for the GradientStop object are:

        * 'stop-color'

        """
        return _libsbml.GradientStop_hasRequiredAttributes(self)


    def toXML(self):
        """
        toXML(GradientStop self) -> XMLNode


        Creates an XMLNode object from this GradientStop object.

        Returns the XMLNode with the XML representation for the  GradientStop
        object.

        """
        return _libsbml.GradientStop_toXML(self)

GradientStop_swigregister = _libsbml.GradientStop_swigregister
GradientStop_swigregister(GradientStop)

class Image(Transformation2D):
    """

    [SBML 'render' package]

    Representation of images.

    The image class represents a bitmap image representation.  It is
    derived from Transformation2D and inherits all its attributes.

    There is an attribute that can be used to specify a file URL where
    that specifies where the image data can be found. If the URL is a
    relative path, it is considered to be relative to the document that
    contains the render extension info.  The path should be the location
    of a JPEG or PNG image, other image formats are currently not
    supported by the SBML Level 3 Render package.

    Additionally it provides an id attribute as well as attributes that
    determine the dimensions and the position of the image relative to its
    viewport.

    """

    __swig_setmethods__ = {}
    for _s in [Transformation2D]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Image, name, value)
    __swig_getmethods__ = {}
    for _s in [Transformation2D]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Image, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(Image self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> Image
        __init__(Image self, unsigned int level, unsigned int version) -> Image
        __init__(Image self, unsigned int level) -> Image
        __init__(Image self) -> Image
        __init__(Image self, RenderPkgNamespaces renderns) -> Image
        __init__(Image self, XMLNode node, unsigned int l2version=4) -> Image
        __init__(Image self, XMLNode node) -> Image
        __init__(Image self, RenderPkgNamespaces renderns, string id) -> Image
        __init__(Image self, Image orig) -> Image


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            Image(long level = RenderExtension.getDefaultLevel(), long
        version = RenderExtension.getDefaultVersion(), long pkgVersion =
        RenderExtension.getDefaultPackageVersion())

        Creates a new Image using the given SBML Level, Version and "render"
        package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        Image.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this Image.

        Parameter 'pkgVersion' is a long integer, the SBML Render Version to
        assign to this Image.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            Image(RenderPkgNamespaces renderns, string id)

        Instantiates an Image object with the given 'id'. The image reference
        is unset, the position and the dimensions values of the image are set
        to 0.

        For the image to be valid, the reference has to be set and it has to
        have dimensions different from and larger than 0.

        WARNING:

        This constructor is deprecated. The new libSBML API uses constructors
        that either take the SBML Level and Version, or take an SBMLNamespaces
        object.

        ______________________________________________________________________
        Method variant with the following signature:

            Image(XMLNode node, long l2version=4)

        Creates a new Image object from the given XMLNode object. The XMLNode
        object has to contain a valid XML representation of a  Image object as
        defined in the render extension specification. This method is normally
        called when render information is read from a file and  should
        normally not have to be called explicitly.

        Parameter 'node' is the XMLNode object reference that describes the
        Image object to be instantiated.

        Parameter 'l2version' is an integer indicating the version of SBML
        Level 2

        ______________________________________________________________________
        Method variant with the following signature:

            Image(Image orig)

        Copy constructor for Image.

        Parameter 'orig' is the Image instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            Image(RenderPkgNamespaces renderns)

        Creates a new Image using the given RenderPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'renderns' is the RenderPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_Image(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(Image self) -> Image


        Creates and returns a deep copy of this Image object.

        Returns a (deep) copy of this Image object.

        """
        return _libsbml.Image_clone(self)

    __swig_destroy__ = _libsbml.delete_Image
    __del__ = lambda self: None

    def getId(self):
        """
        getId(Image self) -> string


        Returns the value of the 'id' attribute of this Image.

        Returns the value of the 'id' attribute of this Image as a string.

        """
        return _libsbml.Image_getId(self)


    def getHref(self):
        """
        getHref(Image self) -> string


        Returns the value of the 'href' attribute of this Image.

        Returns the value of the 'href' attribute of this Image as a string.

        """
        return _libsbml.Image_getHref(self)


    def getImageReference(self):
        """
        getImageReference(Image self) -> string


        Returns the image reference URL string.

        Returns The path to the image data as a string.

        """
        return _libsbml.Image_getImageReference(self)


    def isSetId(self):
        """
        isSetId(Image self) -> bool


        Predicate returning 'True' if this Image's 'id' attribute is set.

        Returns 'True' if this Image's 'id' attribute has been set, otherwise
        'False' is returned.

        """
        return _libsbml.Image_isSetId(self)


    def isSetHref(self):
        """
        isSetHref(Image self) -> bool


        Predicate returning 'True' if this Image's 'href' attribute is set.

        Returns 'True' if this Image's 'href' attribute has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.Image_isSetHref(self)


    def isSetImageReference(self):
        """
        isSetImageReference(Image self) -> bool


        Returns 'True' if the image reference has been set. The image
        reference is considered set if the string does not only contain
        whitespace characters.

        Returns 'True' if the image reference has been set.

        """
        return _libsbml.Image_isSetImageReference(self)


    def setId(self, id):
        """
        setId(Image self, string id) -> int


        Sets the value of the 'id' attribute of this Image.

        Parameter 'id' is string& value of the 'id' attribute to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        Calling this function with 'id' = 'None' or an empty string is
        equivalent to calling unsetId().

        """
        return _libsbml.Image_setId(self, id)


    def setHref(self, href):
        """
        setHref(Image self, string href) -> int


        Sets the value of the 'href' attribute of this Image.

        Parameter 'href' is string& value of the 'href' attribute to be set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        Calling this function with 'href' = 'None' or an empty string is
        equivalent to calling unsetHref().

        """
        return _libsbml.Image_setHref(self, href)


    def setImageReference(self, ref):
        """
        setImageReference(Image self, string ref) -> int


        Sets the reference to the image location. Relative paths are relative
        to the document that contains the render information. The path should
        be the location to a JPEG or PNG bitmap image; other formats are
        currently not supported.

        Parameter 'ref' is A URL string that specifies where the image is
        located on the disk.

        """
        return _libsbml.Image_setImageReference(self, ref)


    def unsetId(self):
        """
        unsetId(Image self) -> int


        Unsets the value of the 'id' attribute of this Image.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Image_unsetId(self)


    def unsetHref(self):
        """
        unsetHref(Image self) -> int


        Unsets the value of the 'href' attribute of this Image.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Image_unsetHref(self)


    def unsetImageReference(self):
        """
        unsetImageReference(Image self) -> int


        Unsets the reference to the image location.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Image_unsetImageReference(self)


    def getX(self, *args):
        """
        getX(Image self) -> RelAbsVector
        getX(Image self) -> RelAbsVector


        Returns a  reference to the x coordinate of the image position.

        Returns reference to the x coordinate of the image position.

        """
        return _libsbml.Image_getX(self, *args)


    def getY(self, *args):
        """
        getY(Image self) -> RelAbsVector
        getY(Image self) -> RelAbsVector


        Returns a  reference to the y coordinate of the image position.

        Returns reference to the y coordinate of the image position.

        """
        return _libsbml.Image_getY(self, *args)


    def getZ(self, *args):
        """
        getZ(Image self) -> RelAbsVector
        getZ(Image self) -> RelAbsVector


        Returns a  reference to the z coordinate of the image position.

        Returns reference to the z coordinate of the image position.

        """
        return _libsbml.Image_getZ(self, *args)


    def getWidth(self, *args):
        """
        getWidth(Image self) -> RelAbsVector
        getWidth(Image self) -> RelAbsVector


        Returns a  reference to the width of the image.

        Returns reference to the width

        """
        return _libsbml.Image_getWidth(self, *args)


    def getHeight(self, *args):
        """
        getHeight(Image self) -> RelAbsVector
        getHeight(Image self) -> RelAbsVector


        Returns a  reference to the height of the image.

        Returns reference to the height

        """
        return _libsbml.Image_getHeight(self, *args)


    def isSetX(self):
        """
        isSetX(Image self) -> bool


        Predicate returning 'True' if this Image's 'x' element is set.

        Returns 'True' if this Image's 'x' element has been set, otherwise
        'False' is returned.

        """
        return _libsbml.Image_isSetX(self)


    def isSetY(self):
        """
        isSetY(Image self) -> bool


        Predicate returning 'True' if this Image's 'y' element is set.

        Returns 'True' if this Image's 'y' element has been set, otherwise
        'False' is returned.

        """
        return _libsbml.Image_isSetY(self)


    def isSetZ(self):
        """
        isSetZ(Image self) -> bool


        Predicate returning 'True' if this Image's 'z' element is set.

        Returns 'True' if this Image's 'z' element has been set, otherwise
        'False' is returned.

        """
        return _libsbml.Image_isSetZ(self)


    def isSetWidth(self):
        """
        isSetWidth(Image self) -> bool


        Predicate returning 'True' if this Image's 'width' element is set.

        Returns 'True' if this Image's 'width' element has been set, otherwise
        'False' is returned.

        """
        return _libsbml.Image_isSetWidth(self)


    def isSetHeight(self):
        """
        isSetHeight(Image self) -> bool


        Predicate returning 'True' if this Image's 'height' element is set.

        Returns 'True' if this Image's 'height' element has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.Image_isSetHeight(self)


    def setCoordinates(self, *args):
        """
        setCoordinates(Image self, RelAbsVector x, RelAbsVector y, RelAbsVector z)
        setCoordinates(Image self, RelAbsVector x, RelAbsVector y)


        Sets the position of the image relative to its viewport. The position
        can either be specified in relative or in absolute coordinates or a
        combination of both. The z coordinate can be omitted. In that case it
        is set to 0.

        Parameter 'x' is x coordinate of the image position Parameter 'y' is y
        coordinate of the image position Parameter 'z' is z coordinate of the
        image position

        """
        return _libsbml.Image_setCoordinates(self, *args)


    def setDimensions(self, width, height):
        """
        setDimensions(Image self, RelAbsVector width, RelAbsVector height)


        Sets the dimensions of the image. The dimensions can be set as
        relative values or absolute values, or  a combination of both.

        Parameter 'width' is the width of the image when rendered Parameter
        'height' is the height of the image when rendered

        """
        return _libsbml.Image_setDimensions(self, width, height)


    def setX(self, coord):
        """
        setX(Image self, RelAbsVector coord) -> int


        Sets the x coordinate of the image position. The position can either
        be specified in relative or in absolute coordinates or a combination
        of both.

        Parameter 'coord' is x-coordinate of the image position

        """
        return _libsbml.Image_setX(self, coord)


    def setY(self, coord):
        """
        setY(Image self, RelAbsVector coord) -> int


        Sets the y coordinate of the image position. The position can either
        be specified in relative or in absolute coordinates or a combination
        of both.

        Parameter 'coord' is y-coordinate of the image position

        """
        return _libsbml.Image_setY(self, coord)


    def setZ(self, coord):
        """
        setZ(Image self, RelAbsVector coord) -> int


        Sets the z coordinate of the image position. The position can either
        be specified in relative or in absolute coordinates or a combination
        of both.

        Parameter 'coord' is z-coordinate of the image position

        """
        return _libsbml.Image_setZ(self, coord)


    def setWidth(self, width):
        """
        setWidth(Image self, RelAbsVector width) -> int


        Sets the width of the image when rendered. The width can be set as
        relative values or absolute values, or  a combination of both.

        Parameter 'width' is the width of the image when rendered

        """
        return _libsbml.Image_setWidth(self, width)


    def setHeight(self, height):
        """
        setHeight(Image self, RelAbsVector height) -> int


        Sets the height of the image when rendered. The height can be set as
        relative values or absolute values, or  a combination of both.

        Parameter 'height' is the height of the image when rendered

        """
        return _libsbml.Image_setHeight(self, height)


    def unsetX(self):
        """
        unsetX(Image self) -> int


        Unsets the value of the 'x' element of this Image.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Image_unsetX(self)


    def unsetY(self):
        """
        unsetY(Image self) -> int


        Unsets the value of the 'y' element of this Image.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Image_unsetY(self)


    def unsetZ(self):
        """
        unsetZ(Image self) -> int


        Unsets the value of the 'z' element of this Image.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Image_unsetZ(self)


    def unsetWidth(self):
        """
        unsetWidth(Image self) -> int


        Unsets the value of the 'width' element of this Image.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Image_unsetWidth(self)


    def unsetHeight(self):
        """
        unsetHeight(Image self) -> int


        Unsets the value of the 'height' element of this Image.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Image_unsetHeight(self)


    def getElementName(self):
        """
        getElementName(Image self) -> string


        Returns the XML element name of this Image object.

        For Image, the XML element name is always ''image'.'

        Returns the name of this element, i.e. ''image'.'

        """
        return _libsbml.Image_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(Image self) -> int


        Returns the libSBML type code for this Image object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_RENDER_IMAGE.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.Image_getTypeCode(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(Image self) -> bool


        Predicate returning 'True' if all the required attributes for this
        Image object have been set.

        Returns 'True' to indicate that all the required attributes of this
        Image have been set, otherwise 'False' is returned.

        Note: The required attributes for the Image object are:

        * 'x'

        * 'y'

        * 'width'

        * 'height'

        * 'href'

        """
        return _libsbml.Image_hasRequiredAttributes(self)


    def toXML(self):
        """
        toXML(Image self) -> XMLNode


        Creates an XMLNode object from this Image object.

        Returns the XMLNode with the XML representation for the  Image object.

        """
        return _libsbml.Image_toXML(self)

Image_swigregister = _libsbml.Image_swigregister
Image_swigregister(Image)

class Text(GraphicalPrimitive1D):
    """

    [SBML 'render' package]

    Representation of text elements.

    The Text class represents text to be rendered in the context of a
    style. The Text class inherits all attributes and methods from its
    base class GraphicalPrimitive1D.

    The text also holds a string for the actual text that is to be
    rendered for the Text object.

    Additional attributes specify how the text is to be rendered, for
    example which font family is to be used and how the text is to be
    aligned within the viewport.

    """

    __swig_setmethods__ = {}
    for _s in [GraphicalPrimitive1D]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Text, name, value)
    __swig_getmethods__ = {}
    for _s in [GraphicalPrimitive1D]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Text, name)
    __repr__ = _swig_repr
    WEIGHT_UNSET = _libsbml.Text_WEIGHT_UNSET
    WEIGHT_NORMAL = _libsbml.Text_WEIGHT_NORMAL
    WEIGHT_BOLD = _libsbml.Text_WEIGHT_BOLD
    WEIGHT_INVALID = _libsbml.Text_WEIGHT_INVALID
    STYLE_UNSET = _libsbml.Text_STYLE_UNSET
    STYLE_NORMAL = _libsbml.Text_STYLE_NORMAL
    STYLE_ITALIC = _libsbml.Text_STYLE_ITALIC
    STYLE_INVALID = _libsbml.Text_STYLE_INVALID
    ANCHOR_UNSET = _libsbml.Text_ANCHOR_UNSET
    ANCHOR_START = _libsbml.Text_ANCHOR_START
    ANCHOR_MIDDLE = _libsbml.Text_ANCHOR_MIDDLE
    ANCHOR_END = _libsbml.Text_ANCHOR_END
    ANCHOR_TOP = _libsbml.Text_ANCHOR_TOP
    ANCHOR_BOTTOM = _libsbml.Text_ANCHOR_BOTTOM
    ANCHOR_BASELINE = _libsbml.Text_ANCHOR_BASELINE
    ANCHOR_INVALID = _libsbml.Text_ANCHOR_INVALID

    def __init__(self, *args):
        """
        __init__(Text self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> Text
        __init__(Text self, unsigned int level, unsigned int version) -> Text
        __init__(Text self, unsigned int level) -> Text
        __init__(Text self) -> Text
        __init__(Text self, RenderPkgNamespaces renderns) -> Text
        __init__(Text self, XMLNode node, unsigned int l2version=4) -> Text
        __init__(Text self, XMLNode node) -> Text
        __init__(Text self, RenderPkgNamespaces renderns, string id, RelAbsVector x, RelAbsVector y, RelAbsVector z) -> Text
        __init__(Text self, RenderPkgNamespaces renderns, string id, RelAbsVector x, RelAbsVector y) -> Text
        __init__(Text self, RenderPkgNamespaces renderns, string id, RelAbsVector x) -> Text
        __init__(Text self, RenderPkgNamespaces renderns, string id) -> Text
        __init__(Text self, Text orig) -> Text


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            Text(long level = RenderExtension.getDefaultLevel(), long
        version = RenderExtension.getDefaultVersion(), long pkgVersion =
        RenderExtension.getDefaultPackageVersion())

        Creates a new Text using the given SBML Level, Version and "render"
        package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        Text.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this Text.

        Parameter 'pkgVersion' is a long integer, the SBML Render Version to
        assign to this Text.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            Text(RenderPkgNamespaces renderns, string id,RelAbsVector
        x=RelAbsVector(0.0,0.0),RelAbsVector
        y=RelAbsVector(0.0,0.0),RelAbsVector z=RelAbsVector(0.0,0.0))

        Instantiates a new Text object with the given 'id' and position
        offset. The position offset coordinates can be omitted and will be set
        to 0 in that case.

        All attributes are set as described for the default constructor of
        GraphicalPrimitive1D. All the font rendering attributes as well  as
        the text to be rendered are unset.

        Parameter 'renderns' is the SBMLNamespaces object for the SBML
        'render' package Parameter 'id' is id string for the Text object
        Parameter 'x' is x coordinate of the position offset Parameter 'y' is
        y coordinate of the position offset Parameter 'z' is z coordinate of
        the position offset

        WARNING:

        This constructor is deprecated. The new libSBML API uses constructors
        that either take the SBML Level and Version, or take an SBMLNamespaces
        object.

        ______________________________________________________________________
        Method variant with the following signature:

            Text(XMLNode node, long l2version=4)

        Creates a new Text object from the given XMLNode object. The XMLNode
        object has to contain a valid XML representation of a  Text object as
        defined in the render extension specification. This method is normally
        called when render information is read from a file and  should
        normally not have to be called explicitly.

        Parameter 'node' is the XMLNode object reference that describes the
        Text object to be instantiated.

        Parameter 'l2version' is an integer indicating the version of SBML
        Level 2

        ______________________________________________________________________
        Method variant with the following signature:

            Text(RenderPkgNamespaces renderns)

        Creates a new Text using the given RenderPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'renderns' is the RenderPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        ______________________________________________________________________
        Method variant with the following signature:

            Text(Text orig)

        Copy constructor for Text.

        Parameter 'orig' is the Text instance to copy.

        """
        this = _libsbml.new_Text(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(Text self) -> Text


        Creates and returns a deep copy of this Text object.

        Returns a (deep) copy of this Text object.

        """
        return _libsbml.Text_clone(self)

    __swig_destroy__ = _libsbml.delete_Text
    __del__ = lambda self: None

    def getFontFamily(self):
        """
        getFontFamily(Text self) -> string


        Returns the value of the 'font-family' attribute of this Text.

        Returns the value of the 'font-family' attribute of this Text as a
        string.

        """
        return _libsbml.Text_getFontFamily(self)


    def getFontWeight(self):
        """
        getFontWeight(Text self) -> int


        Returns the value of the 'font-weight' attribute of this Text.

        The attribute 'font-weight' is used to specify whether  the text is
        to be 'normal' or 'bold'.  If omitted, the text may be rendered in
        either way. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'font-weight':

        * ''bold',' darker and/or thicker than normal print.

        * ''normal',' the typical print weight; lighter and/or thinner than
        'bold'.

        Returns the value of the 'font-weight' attribute of this Text object.

        The possible values returned by this method are:

        * FONT_WEIGHT_BOLD

        * FONT_WEIGHT_NORMAL

        """
        return _libsbml.Text_getFontWeight(self)


    def getFontWeightAsString(self):
        """
        getFontWeightAsString(Text self) -> string


        Returns the value of the 'font-weight' attribute of this Text.

        The attribute 'font-weight' is used to specify whether  the text is
        to be 'normal' or 'bold'.  If omitted, the text may be rendered in
        either way. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'font-weight':

        * ''bold',' darker and/or thicker than normal print.

        * ''normal',' the typical print weight; lighter and/or thinner than
        'bold'.

        Returns the value of the 'font-weight' attribute of this Text as a
        string. The possible values returned by this method are:

        * ''bold''

        * ''normal''

        * ''(Unknown' FontWeight value)'

        """
        return _libsbml.Text_getFontWeightAsString(self)


    def getFontStyle(self):
        """
        getFontStyle(Text self) -> int


        Returns the value of the 'font-style' attribute of this Text.

        The attribute 'font-style' is used to specify whether  the text is to
        be 'normal' or 'italic'.  If omitted, the text may be rendered in
        either way. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'font-style':

        * ''italic',' slanted print

        * ''normal',' upright print

        Returns the value of the 'font-style' attribute of this Text object.

        The possible values returned by this method are:

        * FONT_STYLE_ITALIC

        * FONT_STYLE_NORMAL

        """
        return _libsbml.Text_getFontStyle(self)


    def getFontStyleAsString(self):
        """
        getFontStyleAsString(Text self) -> string


        Returns the value of the 'font-style' attribute of this Text.

        The attribute 'font-style' is used to specify whether  the text is to
        be 'normal' or 'italic'.  If omitted, the text may be rendered in
        either way. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'font-style':

        * ''italic',' slanted print

        * ''normal',' upright print

        Returns the value of the 'font-style' attribute of this Text as a
        string. The possible values returned by this method are:

        * ''italic''

        * ''normal''

        * ''(Unknown' FontStyle value)'

        """
        return _libsbml.Text_getFontStyleAsString(self)


    def getTextAnchor(self):
        """
        getTextAnchor(Text self) -> int


        Returns the value of the 'text-anchor' attribute of this Text.

        The attribute 'text-anchor' is used to specify the  horizontal
        alignment of the text.  If omitted, the text may be aligned in any
        way. In the SBML Level 3 Version 1 Render specification, the following
        are the allowable values for 'text-anchor':

        * ''start',' the start of the text is aligned to the  horizontal
        center  of the box.

        * ''middle',' the horizontal center of the text is aligned to the
        horizontal center of the box.

        * ''end',' the end of the text is aligned to the horizontal center of
        the box.

        Returns the value of the 'text-anchor' attribute of this Text object.
        The possible values returned by this method are:

        * H_TEXTANCHOR_START

        * H_TEXTANCHOR_MIDDLE

        * H_TEXTANCHOR_END

        """
        return _libsbml.Text_getTextAnchor(self)


    def getTextAnchorAsString(self):
        """
        getTextAnchorAsString(Text self) -> string


        Returns the value of the 'text-anchor' attribute of this Text.

        The attribute 'text-anchor' is used to specify the  horizontal
        alignment of the text.  If omitted, the text may be aligned in any
        way. In the SBML Level 3 Version 1 Render specification, the following
        are the allowable values for 'text-anchor':

        * ''start',' the start of the text is aligned to the  horizontal
        center  of the box.

        * ''middle',' the horizontal center of the text is aligned to the
        horizontal center of the box.

        * ''end',' the end of the text is aligned to the horizontal center of
        the box.

        Returns the value of the 'text-anchor' attribute of this Text as a
        string. The possible values returned by this method are:

        * ''start''

        * ''middle''

        * ''end''

        * ''(Unknown' HTextAnchor value)'

        """
        return _libsbml.Text_getTextAnchorAsString(self)


    def getVTextAnchor(self):
        """
        getVTextAnchor(Text self) -> int


        Returns the value of the 'vtext-anchor' attribute of this Text.

        The attribute 'vtext-anchor' is used to specify the  vertical
        alignment of the text.  If omitted, the text may be aligned in any
        way. In the SBML Level 3 Version 1 Render specification, the following
        are the allowable values for 'vtext-anchor':

        * ''top',' the top of the text is aligned to the vertical center of
        the box.

        * ''middle',' the vertical center of the text is aligned with the
        vertical center of the box.

        * ''bottom',' the bottom of the text (i.e. the very bottom of any
        descending letter like 'y' or 'p') is aligned with the vertical
        center of the box.

        * ''baseline',' the baseline of the text (i.e. the bottom of any  non-
        descending letter like 'a' or e') is aligned with the vertical center
        of the box.

        Returns the value of the 'vtext-anchor' attribute of this Text object.
        The possible values returned by this method are:

        * V_TEXTANCHOR_TOP

        * V_TEXTANCHOR_MIDDLE

        * V_TEXTANCHOR_BOTTOM

        * V_TEXTANCHOR_BASELINE

        """
        return _libsbml.Text_getVTextAnchor(self)


    def getVTextAnchorAsString(self):
        """
        getVTextAnchorAsString(Text self) -> string


        Returns the value of the 'vtext-anchor' attribute of this Text.

        The attribute 'vtext-anchor' is used to specify the  vertical
        alignment of the text.  If omitted, the text may be aligned in any
        way. In the SBML Level 3 Version 1 Render specification, the following
        are the allowable values for 'vtext-anchor':

        * ''top',' the top of the text is aligned to the vertical center of
        the box.

        * ''middle',' the vertical center of the text is aligned with the
        vertical center of the box.

        * ''bottom',' the bottom of the text (i.e. the very bottom of any
        descending letter like 'y' or 'p') is aligned with the vertical
        center of the box.

        * ''baseline',' the baseline of the text (i.e. the bottom of any  non-
        descending letter like 'a' or e') is aligned with the vertical center
        of the box.

        Returns the value of the 'vtext-anchor' attribute of this Text as a
        string. The possible values returned by this method are:

        * ''top''

        * ''middle''

        * ''bottom''

        * ''baseline''

        * ''(Unknown' VTextAnchor value)'

        """
        return _libsbml.Text_getVTextAnchorAsString(self)


    def isSetFontFamily(self):
        """
        isSetFontFamily(Text self) -> bool


        Predicate returning 'True' if this Text's 'font-family' attribute is
        set.

        Returns 'True' if this Text's 'font-family' attribute has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.Text_isSetFontFamily(self)


    def isSetFontWeight(self):
        """
        isSetFontWeight(Text self) -> bool


        Predicate returning 'True' if this Text's 'font-weight' attribute is
        set.

        The attribute 'font-weight' is used to specify whether  the text is
        to be 'normal' or 'bold'.  If omitted, the text may be rendered in
        either way. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'font-weight':

        * ''bold',' darker and/or thicker than normal print.

        * ''normal',' the typical print weight; lighter and/or thinner than
        'bold'.

        Returns 'True' if this Text's 'font-weight' attribute has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.Text_isSetFontWeight(self)


    def isSetFontStyle(self):
        """
        isSetFontStyle(Text self) -> bool


        Predicate returning 'True' if this Text's 'font-style' attribute is
        set.

        The attribute 'font-style' is used to specify whether  the text is to
        be 'normal' or 'italic'.  If omitted, the text may be rendered in
        either way. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'font-style':

        * ''italic',' slanted print

        * ''normal',' upright print

        Returns 'True' if this Text's 'font-style' attribute has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.Text_isSetFontStyle(self)


    def isSetTextAnchor(self):
        """
        isSetTextAnchor(Text self) -> bool


        Predicate returning 'True' if this Text's 'text-anchor' attribute is
        set.

        The attribute 'text-anchor' is used to specify the  horizontal
        alignment of the text.  If omitted, the text may be aligned in any
        way. In the SBML Level 3 Version 1 Render specification, the following
        are the allowable values for 'text-anchor':

        * ''start',' the start of the text is aligned to the  horizontal
        center  of the box.

        * ''middle',' the horizontal center of the text is aligned to the
        horizontal center of the box.

        * ''end',' the end of the text is aligned to the horizontal center of
        the box.

        Returns 'True' if this Text's 'text-anchor' attribute has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.Text_isSetTextAnchor(self)


    def isSetVTextAnchor(self):
        """
        isSetVTextAnchor(Text self) -> bool


        Predicate returning 'True' if this Text's 'vtext-anchor' attribute is
        set.

        The attribute 'vtext-anchor' is used to specify the  vertical
        alignment of the text.  If omitted, the text may be aligned in any
        way. In the SBML Level 3 Version 1 Render specification, the following
        are the allowable values for 'vtext-anchor':

        * ''top',' the top of the text is aligned to the vertical center of
        the box.

        * ''middle',' the vertical center of the text is aligned with the
        vertical center of the box.

        * ''bottom',' the bottom of the text (i.e. the very bottom of any
        descending letter like 'y' or 'p') is aligned with the vertical
        center of the box.

        * ''baseline',' the baseline of the text (i.e. the bottom of any  non-
        descending letter like 'a' or e') is aligned with the vertical center
        of the box.

        Returns 'True' if this Text's 'vtext-anchor' attribute has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.Text_isSetVTextAnchor(self)


    def setFontFamily(self, fontFamily):
        """
        setFontFamily(Text self, string fontFamily) -> int


        Sets the value of the 'font-family' attribute of this Text.

        Parameter 'fontFamily' is string& value of the 'font-family' attribute
        to be set. Calling this function with 'fontFamily' = 'None' or an
        empty string is equivalent to calling unsetFontFamily().

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.Text_setFontFamily(self, fontFamily)


    def setFontWeight(self, *args):
        """
        setFontWeight(Text self, FontWeight_t const fontWeight) -> int
        setFontWeight(Text self, Text::FONT_WEIGHT weight)
        setFontWeight(Text self, string fontWeight) -> int


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            setFontWeight(string fontWeight)

        Sets the value of the 'font-weight' attribute of this Text.

        The attribute 'font-weight' is used to specify whether  the text is
        to be 'normal' or 'bold'.  If omitted, the text may be rendered in
        either way. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'font-weight':

        * ''bold',' darker and/or thicker than normal print.

        * ''normal',' the typical print weight; lighter and/or thinner than
        'bold'.

        Parameter 'fontWeight' is the value of the 'font-weight' attribute to
        be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        ______________________________________________________________________
        Method variant with the following signature:

            setFontWeight( FontWeight_t fontWeight)

        Sets the value of the 'font-weight' attribute of this Text.

        The attribute 'font-weight' is used to specify whether  the text is
        to be 'normal' or 'bold'.  If omitted, the text may be rendered in
        either way. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'font-weight':

        * ''bold',' darker and/or thicker than normal print.

        * ''normal',' the typical print weight; lighter and/or thinner than
        'bold'.

        Parameter 'fontWeight' is int value of the 'font-weight' attribute to
        be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Text_setFontWeight(self, *args)


    def setFontStyle(self, *args):
        """
        setFontStyle(Text self, FontStyle_t const fontStyle) -> int
        setFontStyle(Text self, Text::FONT_STYLE style)
        setFontStyle(Text self, string fontStyle) -> int


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            setFontStyle(string fontStyle)

        Sets the value of the 'font-style' attribute of this Text.

        The attribute 'font-style' is used to specify whether  the text is to
        be 'normal' or 'italic'.  If omitted, the text may be rendered in
        either way. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'font-style':

        * ''italic',' slanted print

        * ''normal',' upright print

        Parameter 'fontStyle' is the 'font-style' attribute to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        ______________________________________________________________________
        Method variant with the following signature:

            setFontStyle( FontStyle_t fontStyle)

        Sets the value of the 'font-style' attribute of this Text.

        The attribute 'font-style' is used to specify whether  the text is to
        be 'normal' or 'italic'.  If omitted, the text may be rendered in
        either way. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'font-style':

        * ''italic',' slanted print

        * ''normal',' upright print

        Parameter 'fontStyle' is int value of the 'font-style' attribute to be
        set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Text_setFontStyle(self, *args)


    def setTextAnchor(self, *args):
        """
        setTextAnchor(Text self, HTextAnchor_t const textAnchor) -> int
        setTextAnchor(Text self, Text::TEXT_ANCHOR anchor)
        setTextAnchor(Text self, string textAnchor) -> int


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            setTextAnchor( HTextAnchor_t textAnchor)

        Sets the value of the 'text-anchor' attribute of this Text.

        The attribute 'text-anchor' is used to specify the  horizontal
        alignment of the text.  If omitted, the text may be aligned in any
        way. In the SBML Level 3 Version 1 Render specification, the following
        are the allowable values for 'text-anchor':

        * ''start',' the start of the text is aligned to the  horizontal
        center  of the box.

        * ''middle',' the horizontal center of the text is aligned to the
        horizontal center of the box.

        * ''end',' the end of the text is aligned to the horizontal center of
        the box.

        Parameter 'textAnchor' is int value of the 'text-anchor' attribute to
        be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        ______________________________________________________________________
        Method variant with the following signature:

            setTextAnchor(string textAnchor)

        Sets the value of the 'text-anchor' attribute of this Text.

        The attribute 'text-anchor' is used to specify the  horizontal
        alignment of the text.  If omitted, the text may be aligned in any
        way. In the SBML Level 3 Version 1 Render specification, the following
        are the allowable values for 'text-anchor':

        * ''start',' the start of the text is aligned to the  horizontal
        center  of the box.

        * ''middle',' the horizontal center of the text is aligned to the
        horizontal center of the box.

        * ''end',' the end of the text is aligned to the horizontal center of
        the box.

        Parameter 'textAnchor' is the value of the 'text-anchor' attribute to
        be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Text_setTextAnchor(self, *args)


    def setVTextAnchor(self, *args):
        """
        setVTextAnchor(Text self, VTextAnchor_t const vtextAnchor) -> int
        setVTextAnchor(Text self, Text::TEXT_ANCHOR anchor)
        setVTextAnchor(Text self, string vtextAnchor) -> int


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            setVTextAnchor(string vtextAnchor)

        Sets the value of the 'vtext-anchor' attribute of this Text.

        The attribute 'vtext-anchor' is used to specify the  vertical
        alignment of the text.  If omitted, the text may be aligned in any
        way. In the SBML Level 3 Version 1 Render specification, the following
        are the allowable values for 'vtext-anchor':

        * ''top',' the top of the text is aligned to the vertical center of
        the box.

        * ''middle',' the vertical center of the text is aligned with the
        vertical center of the box.

        * ''bottom',' the bottom of the text (i.e. the very bottom of any
        descending letter like 'y' or 'p') is aligned with the vertical
        center of the box.

        * ''baseline',' the baseline of the text (i.e. the bottom of any  non-
        descending letter like 'a' or e') is aligned with the vertical center
        of the box.

        Parameter 'vtextAnchor' is the value of the 'vtext-anchor' attribute
        to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        ______________________________________________________________________
        Method variant with the following signature:

            setVTextAnchor( VTextAnchor_t vtextAnchor)

        Sets the value of the 'vtext-anchor' attribute of this Text.

        The attribute 'vtext-anchor' is used to specify the  vertical
        alignment of the text.  If omitted, the text may be aligned in any
        way. In the SBML Level 3 Version 1 Render specification, the following
        are the allowable values for 'vtext-anchor':

        * ''top',' the top of the text is aligned to the vertical center of
        the box.

        * ''middle',' the vertical center of the text is aligned with the
        vertical center of the box.

        * ''bottom',' the bottom of the text (i.e. the very bottom of any
        descending letter like 'y' or 'p') is aligned with the vertical
        center of the box.

        * ''baseline',' the baseline of the text (i.e. the bottom of any  non-
        descending letter like 'a' or e') is aligned with the vertical center
        of the box.

        Parameter 'vtextAnchor' is int value of the 'vtext-anchor' attribute
        to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.Text_setVTextAnchor(self, *args)


    def unsetFontFamily(self):
        """
        unsetFontFamily(Text self) -> int


        Unsets the value of the 'font-family' attribute of this Text.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Text_unsetFontFamily(self)


    def unsetFontWeight(self):
        """
        unsetFontWeight(Text self) -> int


        Unsets the value of the 'font-weight' attribute of this Text.

        The attribute 'font-weight' is used to specify whether  the text is
        to be 'normal' or 'bold'.  If omitted, the text may be rendered in
        either way. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'font-weight':

        * ''bold',' darker and/or thicker than normal print.

        * ''normal',' the typical print weight; lighter and/or thinner than
        'bold'.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.Text_unsetFontWeight(self)


    def unsetFontStyle(self):
        """
        unsetFontStyle(Text self) -> int


        Unsets the value of the 'font-style' attribute of this Text.

        The attribute 'font-style' is used to specify whether  the text is to
        be 'normal' or 'italic'.  If omitted, the text may be rendered in
        either way. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'font-style':

        * ''italic',' slanted print

        * ''normal',' upright print

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.Text_unsetFontStyle(self)


    def unsetTextAnchor(self):
        """
        unsetTextAnchor(Text self) -> int


        Unsets the value of the 'text-anchor' attribute of this Text.

        The attribute 'text-anchor' is used to specify the  horizontal
        alignment of the text.  If omitted, the text may be aligned in any
        way. In the SBML Level 3 Version 1 Render specification, the following
        are the allowable values for 'text-anchor':

        * ''start',' the start of the text is aligned to the  horizontal
        center  of the box.

        * ''middle',' the horizontal center of the text is aligned to the
        horizontal center of the box.

        * ''end',' the end of the text is aligned to the horizontal center of
        the box.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.Text_unsetTextAnchor(self)


    def unsetVTextAnchor(self):
        """
        unsetVTextAnchor(Text self) -> int


        Unsets the value of the 'vtext-anchor' attribute of this Text.

        The attribute 'vtext-anchor' is used to specify the  vertical
        alignment of the text.  If omitted, the text may be aligned in any
        way. In the SBML Level 3 Version 1 Render specification, the following
        are the allowable values for 'vtext-anchor':

        * ''top',' the top of the text is aligned to the vertical center of
        the box.

        * ''middle',' the vertical center of the text is aligned with the
        vertical center of the box.

        * ''bottom',' the bottom of the text (i.e. the very bottom of any
        descending letter like 'y' or 'p') is aligned with the vertical
        center of the box.

        * ''baseline',' the baseline of the text (i.e. the bottom of any  non-
        descending letter like 'a' or e') is aligned with the vertical center
        of the box.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.Text_unsetVTextAnchor(self)


    def getX(self, *args):
        """
        getX(Text self) -> RelAbsVector
        getX(Text self) -> RelAbsVector


        Returns the x position offset as a  reference. This offset is applied
        after alignment.

        Returns reference of x position offset

        """
        return _libsbml.Text_getX(self, *args)


    def getY(self, *args):
        """
        getY(Text self) -> RelAbsVector
        getY(Text self) -> RelAbsVector


        Returns the y position offset as a  reference. This offset is applied
        after alignment.

        Returns reference of y position offset

        """
        return _libsbml.Text_getY(self, *args)


    def getZ(self, *args):
        """
        getZ(Text self) -> RelAbsVector
        getZ(Text self) -> RelAbsVector


        Returns the z position offset as a  reference. This offset is applied
        after alignment.

        Returns reference of z position offset

        """
        return _libsbml.Text_getZ(self, *args)


    def getFontSize(self, *args):
        """
        getFontSize(Text self) -> RelAbsVector
        getFontSize(Text self) -> RelAbsVector


        Returns the font size as a  reference.

        Returns reference to the size to be used for rendering text.

        """
        return _libsbml.Text_getFontSize(self, *args)


    def isSetX(self):
        """
        isSetX(Text self) -> bool


        Predicate returning 'True' if this Text's 'x' element is set.

        Returns 'True' if this Text's 'x' element has been set, otherwise
        'False' is returned.

        """
        return _libsbml.Text_isSetX(self)


    def isSetY(self):
        """
        isSetY(Text self) -> bool


        Predicate returning 'True' if this Text's 'y' element is set.

        Returns 'True' if this Text's 'y' element has been set, otherwise
        'False' is returned.

        """
        return _libsbml.Text_isSetY(self)


    def isSetZ(self):
        """
        isSetZ(Text self) -> bool


        Predicate returning 'True' if this Text's 'z' element is set.

        Returns 'True' if this Text's 'z' element has been set, otherwise
        'False' is returned.

        """
        return _libsbml.Text_isSetZ(self)


    def isSetFontSize(self):
        """
        isSetFontSize(Text self) -> bool


        Predicate returning 'True' if this Text's 'font-size' element is set.

        Returns 'True' if this Text's 'font-size' element has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.Text_isSetFontSize(self)


    def setCoordinates(self, *args):
        """
        setCoordinates(Text self, RelAbsVector x, RelAbsVector y, RelAbsVector z)
        setCoordinates(Text self, RelAbsVector x, RelAbsVector y)


        Sets the position of the text within the viewport. This is like an
        offset that is applied after alignment. If the z coordinate is
        omitted, it is set to 0.

        Parameter 'x' is x coordinate of the position offset Parameter 'y' is
        y coordinate of the position offset Parameter 'z' is z coordinate of
        the position offset

        """
        return _libsbml.Text_setCoordinates(self, *args)


    def setX(self, x):
        """
        setX(Text self, RelAbsVector x) -> int


        Sets the x position of the text within the viewport. This is like an
        offset that is applied after alignment.

        Parameter 'x' is x coordinate of the position offset

        """
        return _libsbml.Text_setX(self, x)


    def setY(self, y):
        """
        setY(Text self, RelAbsVector y) -> int


        Sets the y position of the text within the viewport. This is like an
        offset that is applied after alignment.

        Parameter 'y' is y coordinate of the position offset

        """
        return _libsbml.Text_setY(self, y)


    def setZ(self, z):
        """
        setZ(Text self, RelAbsVector z) -> int


        Sets the z position of the text within the viewport. This is like an
        offset that is applied after alignment.

        Parameter 'z' is z coordinate of the position offset

        """
        return _libsbml.Text_setZ(self, z)


    def setFontSize(self, size):
        """
        setFontSize(Text self, RelAbsVector size) -> int


        Sets the font size. Normally this is an absolute value, e.g. 18 for a
        18pt font. It is however allowed the specify the font size in terms of
        relative values in relation to the current viewport. In most cases the
        viewport will be the  dimensions of a bounding box of a layout object.

        Parameter 'size' is the new font size.

        """
        return _libsbml.Text_setFontSize(self, size)


    def unsetX(self):
        """
        unsetX(Text self) -> int


        Unsets the value of the 'x' element of this Text.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Text_unsetX(self)


    def unsetY(self):
        """
        unsetY(Text self) -> int


        Unsets the value of the 'y' element of this Text.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Text_unsetY(self)


    def unsetZ(self):
        """
        unsetZ(Text self) -> int


        Unsets the value of the 'z' element of this Text.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Text_unsetZ(self)


    def unsetFontSize(self):
        """
        unsetFontSize(Text self) -> int


        Unsets the value of the 'font-size' element of this Text.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Text_unsetFontSize(self)


    def getText(self):
        """
        getText(Text self) -> string


        Returns the text for the Text object.

        Returns the text string to be rendered for the Text object.

        """
        return _libsbml.Text_getText(self)


    def isSetText(self):
        """
        isSetText(Text self) -> bool


        Returns 'True' if the text is set to something else than the empty
        string.

        Returns 'True' if the text is not empty.

        """
        return _libsbml.Text_isSetText(self)


    def setText(self, text):
        """
        setText(Text self, string text) -> int


        Sets the text for the text element.

        Parameter 'text' is The text to be rendered for the Text object.

        """
        return _libsbml.Text_setText(self, text)


    def unsetText(self):
        """
        unsetText(Text self) -> int


        Unsets the text for the text element.

        """
        return _libsbml.Text_unsetText(self)


    def getElementName(self):
        """
        getElementName(Text self) -> string


        Returns the XML element name of this Text object.

        For Text, the XML element name is always ''text'.'

        Returns the name of this element, i.e. ''text'.'

        """
        return _libsbml.Text_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(Text self) -> int


        Returns the libSBML type code for this Text object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_RENDER_TEXT.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.Text_getTypeCode(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(Text self) -> bool


        Predicate returning 'True' if all the required attributes for this
        Text object have been set.

        Returns 'True' to indicate that all the required attributes of this
        Text have been set, otherwise 'False' is returned.

        """
        return _libsbml.Text_hasRequiredAttributes(self)


    def toXML(self):
        """
        toXML(Text self) -> XMLNode


        Creates an Text object from this Group object.

        Returns the XMLNode with the XML representation for the  Text object.

        """
        return _libsbml.Text_toXML(self)

Text_swigregister = _libsbml.Text_swigregister
Text_swigregister(Text)


def TextAnchor_fromString(str):
    """TextAnchor_fromString(char const * str) -> Text::TEXT_ANCHOR"""
    return _libsbml.TextAnchor_fromString(str)

def TextAnchor_toString(anchor):
    """TextAnchor_toString(Text::TEXT_ANCHOR anchor) -> char const *"""
    return _libsbml.TextAnchor_toString(anchor)
class Rectangle(GraphicalPrimitive2D):
    """

    [SBML 'render' package]

    Representation of a rectangle.

    Rectangle allows the definition of rectangles with or without rounded
    edges.  The Rectangle object derives from the GraphicalPrimitive2D
    class and thus inherits any attributes and elements that are present
    on this class.  In addition, the Rectangle object has the required
    attributes 'x', 'y', 'height', and 'width' as well as the optional
    attributes 'z', 'rx', 'ry' and 'ratio'.

    """

    __swig_setmethods__ = {}
    for _s in [GraphicalPrimitive2D]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Rectangle, name, value)
    __swig_getmethods__ = {}
    for _s in [GraphicalPrimitive2D]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Rectangle, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(Rectangle self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> Rectangle
        __init__(Rectangle self, unsigned int level, unsigned int version) -> Rectangle
        __init__(Rectangle self, unsigned int level) -> Rectangle
        __init__(Rectangle self) -> Rectangle
        __init__(Rectangle self, RenderPkgNamespaces renderns) -> Rectangle
        __init__(Rectangle self, XMLNode node, unsigned int l2version=4) -> Rectangle
        __init__(Rectangle self, XMLNode node) -> Rectangle
        __init__(Rectangle self, RenderPkgNamespaces renderns, string id) -> Rectangle
        __init__(Rectangle self, RenderPkgNamespaces renderns, string id, RelAbsVector x, RelAbsVector y, RelAbsVector z, RelAbsVector w, RelAbsVector h) -> Rectangle
        __init__(Rectangle self, RenderPkgNamespaces renderns, string id, RelAbsVector x, RelAbsVector y, RelAbsVector w, RelAbsVector h) -> Rectangle
        __init__(Rectangle self, Rectangle orig) -> Rectangle


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            Rectangle(long level = RenderExtension.getDefaultLevel(),
        long version = RenderExtension.getDefaultVersion(), long pkgVersion =
        RenderExtension.getDefaultPackageVersion())

        Creates a new Rectangle using the given SBML Level, Version and
        "render" package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        Rectangle.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this Rectangle.

        Parameter 'pkgVersion' is a long integer, the SBML Render Version to
        assign to this Rectangle.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            Rectangle(Rectangle orig)

        Copy constructor for Rectangle.

        Parameter 'orig' is the Rectangle instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            Rectangle(RenderPkgNamespaces renderns, string
        id,RelAbsVector x,RelAbsVector y,RelAbsVector w,RelAbsVector h)

        Instantiates a new Rectangle object. All attributes are set as
        described for the default constructor of GraphicalPrimitive2D.

        The id is set to the given string and all rectangle specific
        attributes are set to the given values. The z coordinate of the
        position is set to 0.

        Parameter 'renderns' is the SBMLNamespaces object for the SBML
        'render' package Parameter 'id' is id string for the rectangle
        Parameter 'x' is x coordinate of the position  Parameter 'y' is y
        coordinate of the position  Parameter 'w' is w width Parameter 'h' is
        h height

        WARNING:

        This constructor is deprecated. The new libSBML API uses constructors
        that either take the SBML Level and Version, or take an SBMLNamespaces
        object.

        ______________________________________________________________________
        Method variant with the following signature:

            Rectangle(RenderPkgNamespaces renderns)

        Creates a new Rectangle using the given RenderPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'renderns' is the RenderPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        ______________________________________________________________________
        Method variant with the following signature:

            Rectangle(RenderPkgNamespaces renderns, string
        id,RelAbsVector x,RelAbsVector y,RelAbsVector z,RelAbsVector
        w,RelAbsVector h)

        Instantiates a new Rectangle object. All attributes are set as
        described for the default constructor of GraphicalPrimitive2D.

        The id is set to the given string and all rectangle specific
        attributes are set to the given values.

        Parameter 'renderns' is the SBMLNamespaces object for the SBML
        'render' package Parameter 'id' is id string for the rectangle
        Parameter 'x' is x coordinate of the position  Parameter 'y' is y
        coordinate of the position  Parameter 'z' is z coordinate of the
        position  Parameter 'w' is w width Parameter 'h' is h height

        WARNING:

        This constructor is deprecated. The new libSBML API uses constructors
        that either take the SBML Level and Version, or take an SBMLNamespaces
        object.

        ______________________________________________________________________
        Method variant with the following signature:

            Rectangle(XMLNode node, long l2version=4)

        Creates a new Rectangle object from the given XMLNode object. The
        XMLNode object has to contain a valid XML representation of a
        Rectangle object as defined in the render extension specification.
        This method is normally called when render information is read from a
        file and  should normally not have to be called explicitly.

        Parameter 'node' is the XMLNode object reference that describes the
        Rectangle object to be instantiated.

        Parameter 'l2version' is an integer indicating the version of SBML
        Level 2

        ______________________________________________________________________
        Method variant with the following signature:

            Rectangle(RenderPkgNamespaces renderns, string id)

        Instantiates a new Rectangle object. All attributes are set as
        described for the default constructor of GraphicalPrimitive2D.

        The id is set to the given string and all rectangle specific
        attributes are set to 0.

        Parameter 'renderns' is the SBMLNamespaces object for the SBML
        'render' package Parameter 'id' is id string for the rectangle

        WARNING:

        This constructor is deprecated. The new libSBML API uses constructors
        that either take the SBML Level and Version, or take an SBMLNamespaces
        object.

        """
        this = _libsbml.new_Rectangle(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(Rectangle self) -> Rectangle


        Creates and returns a deep copy of this Rectangle object.

        Returns a (deep) copy of this Rectangle object.

        """
        return _libsbml.Rectangle_clone(self)

    __swig_destroy__ = _libsbml.delete_Rectangle
    __del__ = lambda self: None

    def getRatio(self):
        """
        getRatio(Rectangle self) -> double


        Returns the value of the 'ratio' attribute of this Rectangle.

        Returns the value of the 'ratio' attribute of this Rectangle as a
        double.

        """
        return _libsbml.Rectangle_getRatio(self)


    def isSetRatio(self):
        """
        isSetRatio(Rectangle self) -> bool


        Predicate returning 'True' if this Rectangle's 'ratio' attribute is
        set.

        Returns 'True' if this Rectangle's 'ratio' attribute has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.Rectangle_isSetRatio(self)


    def setRatio(self, ratio):
        """
        setRatio(Rectangle self, double ratio) -> int


        Sets the value of the 'ratio' attribute of this Rectangle.

        Parameter 'ratio' is double value of the 'ratio' attribute to be set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS OperationReturnValues_t}

        """
        return _libsbml.Rectangle_setRatio(self, ratio)


    def unsetRatio(self):
        """
        unsetRatio(Rectangle self) -> int


        Unsets the value of the 'ratio' attribute of this Rectangle.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.Rectangle_unsetRatio(self)


    def getX(self, *args):
        """
        getX(Rectangle self) -> RelAbsVector
        getX(Rectangle self) -> RelAbsVector


        Returns the x coordinate of the rectangle's position

        Returns reference to RelAbsVector that represents the x position

        """
        return _libsbml.Rectangle_getX(self, *args)


    def getY(self, *args):
        """
        getY(Rectangle self) -> RelAbsVector
        getY(Rectangle self) -> RelAbsVector


        Returns the y coordinate of the rectangle's position

        Returns reference to RelAbsVector that represents the y position

        """
        return _libsbml.Rectangle_getY(self, *args)


    def getZ(self, *args):
        """
        getZ(Rectangle self) -> RelAbsVector
        getZ(Rectangle self) -> RelAbsVector


        Returns the z coordinate of the rectangle's position

        Returns reference to RelAbsVector that represents the z position

        """
        return _libsbml.Rectangle_getZ(self, *args)


    def getWidth(self, *args):
        """
        getWidth(Rectangle self) -> RelAbsVector
        getWidth(Rectangle self) -> RelAbsVector


        Returns the with of the rectangle

        Returns reference to the RelAbsVector that represents the width

        """
        return _libsbml.Rectangle_getWidth(self, *args)


    def getHeight(self, *args):
        """
        getHeight(Rectangle self) -> RelAbsVector
        getHeight(Rectangle self) -> RelAbsVector


        Returns the height of the rectangle

        Returns reference to the RelAbsVector that represents the height

        """
        return _libsbml.Rectangle_getHeight(self, *args)


    def getRX(self, *args):
        """
        getRX(Rectangle self) -> RelAbsVector
        getRX(Rectangle self) -> RelAbsVector


        Returns the value of the 'rX' element of this Rectangle.

        Returns the value of the 'rX' element of this Rectangle as a
        RelAbsVector.

        """
        return _libsbml.Rectangle_getRX(self, *args)


    def getRadiusX(self, *args):
        """
        getRadiusX(Rectangle self) -> RelAbsVector
        getRadiusX(Rectangle self) -> RelAbsVector


        Returns the corner radius along the x axis

        Returns reference to the RelAbsVector that corner radius along the x
        axis

        """
        return _libsbml.Rectangle_getRadiusX(self, *args)


    def getRY(self, *args):
        """
        getRY(Rectangle self) -> RelAbsVector
        getRY(Rectangle self) -> RelAbsVector


        Returns the value of the 'rY' element of this Rectangle.

        Returns the value of the 'rY' element of this Rectangle as a
        RelAbsVector.

        """
        return _libsbml.Rectangle_getRY(self, *args)


    def getRadiusY(self, *args):
        """
        getRadiusY(Rectangle self) -> RelAbsVector
        getRadiusY(Rectangle self) -> RelAbsVector


        Returns the corner radius along the y axis

        Returns reference to the RelAbsVector that corner radius along the y
        axis

        """
        return _libsbml.Rectangle_getRadiusY(self, *args)


    def isSetX(self):
        """
        isSetX(Rectangle self) -> bool


        Predicate returning 'True' if this Rectangle's 'x' attribute is set.

        Returns 'True' if this Rectangle's 'x' attribute has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.Rectangle_isSetX(self)


    def isSetY(self):
        """
        isSetY(Rectangle self) -> bool


        Predicate returning 'True' if this Rectangle's 'y' attribute is set.

        Returns 'True' if this Rectangle's 'y' attribute has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.Rectangle_isSetY(self)


    def isSetZ(self):
        """
        isSetZ(Rectangle self) -> bool


        Predicate returning 'True' if this Rectangle's 'z' attribute is set.

        Returns 'True' if this Rectangle's 'z' attribute has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.Rectangle_isSetZ(self)


    def isSetWidth(self):
        """
        isSetWidth(Rectangle self) -> bool


        Predicate returning 'True' if this Rectangle's 'width' attribute is
        set.

        Returns 'True' if this Rectangle's 'width' attribute has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.Rectangle_isSetWidth(self)


    def isSetHeight(self):
        """
        isSetHeight(Rectangle self) -> bool


        Predicate returning 'True' if this Rectangle's 'height' attribute is
        set.

        Returns 'True' if this Rectangle's 'height' attribute has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.Rectangle_isSetHeight(self)


    def isSetRX(self):
        """
        isSetRX(Rectangle self) -> bool


        Predicate returning 'True' if this Rectangle's 'rX' attribute is set.

        Returns 'True' if this Rectangle's 'rX' attribute has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.Rectangle_isSetRX(self)


    def isSetRadiusX(self):
        """
        isSetRadiusX(Rectangle self) -> bool


        Predicate returning 'True' if this Rectangle's 'rX' attribute is set.

        Returns 'True' if this Rectangle's 'rX' attribute has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.Rectangle_isSetRadiusX(self)


    def isSetRY(self):
        """
        isSetRY(Rectangle self) -> bool


        Predicate returning 'True' if this Rectangle's 'rY' attribute is set.

        Returns 'True' if this Rectangle's 'rY' attribute has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.Rectangle_isSetRY(self)


    def isSetRadiusY(self):
        """
        isSetRadiusY(Rectangle self) -> bool


        Predicate returning 'True' if this Rectangle's 'rY' attribute is set.

        Returns 'True' if this Rectangle's 'rY' attribute has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.Rectangle_isSetRadiusY(self)


    def setCoordinatesAndSize(self, x, y, z, w, h):
        """
        setCoordinatesAndSize(Rectangle self, RelAbsVector x, RelAbsVector y, RelAbsVector z, RelAbsVector w, RelAbsVector h)


        Sets the position and the size of the Rectangle within the viewport.

        Parameter 'x' is x coordinate of the position  Parameter 'y' is y
        coordinate of the position  Parameter 'z' is z coordinate of the
        position  Parameter 'w' is w width Parameter 'h' is h height

        """
        return _libsbml.Rectangle_setCoordinatesAndSize(self, x, y, z, w, h)


    def setCoordinates(self, x, y, z):
        """
        setCoordinates(Rectangle self, RelAbsVector x, RelAbsVector y, RelAbsVector z)


        Sets the position of the Rectangle within the viewport.

        Parameter 'x' is x coordinate of the position  Parameter 'y' is y
        coordinate of the position  Parameter 'z' is z coordinate of the
        position

        """
        return _libsbml.Rectangle_setCoordinates(self, x, y, z)


    def setSize(self, w, h):
        """
        setSize(Rectangle self, RelAbsVector w, RelAbsVector h)


        Sets the size of the Rectangle

        Parameter 'w' is w width Parameter 'h' is h height

        """
        return _libsbml.Rectangle_setSize(self, w, h)


    def setRadii(self, rx, ry):
        """
        setRadii(Rectangle self, RelAbsVector rx, RelAbsVector ry)


        Sets the two corner radii of the rectangle

        Parameter 'rx' is corner radius along the x axis Parameter 'ry' is
        corner radius along the y axis

        """
        return _libsbml.Rectangle_setRadii(self, rx, ry)


    def setX(self, x):
        """
        setX(Rectangle self, RelAbsVector x) -> int


        Sets the x position of the Rectangle within the viewport.

        Parameter 'x' is x coordinate of the position

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.Rectangle_setX(self, x)


    def setY(self, y):
        """
        setY(Rectangle self, RelAbsVector y) -> int


        Sets the y position of the Rectangle within the viewport.

        Parameter 'y' is y coordinate of the position

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.Rectangle_setY(self, y)


    def setZ(self, z):
        """
        setZ(Rectangle self, RelAbsVector z) -> int


        Sets the z position of the Rectangle within the viewport.

        Parameter 'z' is z coordinate of the position

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.Rectangle_setZ(self, z)


    def setWidth(self, w):
        """
        setWidth(Rectangle self, RelAbsVector w) -> int


        Sets the width of the Rectangle

        Parameter 'w' is w width

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.Rectangle_setWidth(self, w)


    def setHeight(self, h):
        """
        setHeight(Rectangle self, RelAbsVector h) -> int


        Sets the height of the Rectangle

        Parameter 'h' is h height

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.Rectangle_setHeight(self, h)


    def setRadiusX(self, rx):
        """
        setRadiusX(Rectangle self, RelAbsVector rx) -> int


        Sets the corner radius along the x axis

        Parameter 'rx' is corner radius along the x axis

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.Rectangle_setRadiusX(self, rx)


    def setRX(self, rx):
        """
        setRX(Rectangle self, RelAbsVector rx) -> int


        Sets the corner radius along the x axis

        Parameter 'rx' is corner radius along the x axis

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.Rectangle_setRX(self, rx)


    def setRadiusY(self, ry):
        """
        setRadiusY(Rectangle self, RelAbsVector ry) -> int


        Sets the corner radius along the y axis

        Parameter 'ry' is corner radius along the y axis

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.Rectangle_setRadiusY(self, ry)


    def setRY(self, ry):
        """
        setRY(Rectangle self, RelAbsVector ry) -> int


        Sets the corner radius along the y axis

        Parameter 'ry' is corner radius along the y axis

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.Rectangle_setRY(self, ry)


    def unsetX(self):
        """
        unsetX(Rectangle self) -> int


        Unsets the value of the 'x' attribute of this Rectangle.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.Rectangle_unsetX(self)


    def unsetY(self):
        """
        unsetY(Rectangle self) -> int


        Unsets the value of the 'y' attribute of this Rectangle.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.Rectangle_unsetY(self)


    def unsetZ(self):
        """
        unsetZ(Rectangle self) -> int


        Unsets the value of the 'z' attribute of this Rectangle.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.Rectangle_unsetZ(self)


    def unsetWidth(self):
        """
        unsetWidth(Rectangle self) -> int


        Unsets the value of the 'width' attribute of this Rectangle.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.Rectangle_unsetWidth(self)


    def unsetHeight(self):
        """
        unsetHeight(Rectangle self) -> int


        Unsets the value of the 'height' attribute of this Rectangle.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.Rectangle_unsetHeight(self)


    def unsetRadiusX(self):
        """
        unsetRadiusX(Rectangle self) -> int


        Unsets the value of the 'rX' attribute of this Rectangle.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.Rectangle_unsetRadiusX(self)


    def unsetRX(self):
        """
        unsetRX(Rectangle self) -> int


        Unsets the value of the 'rX' attribute of this Rectangle.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.Rectangle_unsetRX(self)


    def unsetRadiusY(self):
        """
        unsetRadiusY(Rectangle self) -> int


        Unsets the value of the 'rY' attribute of this Rectangle.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.Rectangle_unsetRadiusY(self)


    def unsetRY(self):
        """
        unsetRY(Rectangle self) -> int


        Unsets the value of the 'rY' attribute of this Rectangle.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.Rectangle_unsetRY(self)


    def getElementName(self):
        """
        getElementName(Rectangle self) -> string


        Returns the XML element name of this Rectangle object.

        For Rectangle, the XML element name is always ''rectangle'.'

        Returns the name of this element, i.e. ''rectangle'.'

        """
        return _libsbml.Rectangle_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(Rectangle self) -> int


        Returns the libSBML type code for this Rectangle object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_RENDER_RECTANGLE.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.Rectangle_getTypeCode(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(Rectangle self) -> bool


        Predicate returning 'True' if all the required attributes for this
        Rectangle object have been set.

        Returns 'True' to indicate that all the required attributes of this
        Rectangle have been set, otherwise 'False' is returned.

        """
        return _libsbml.Rectangle_hasRequiredAttributes(self)


    def toXML(self):
        """
        toXML(Rectangle self) -> XMLNode


        Creates an XMLNode object from this Rectangle object.

        Returns the XMLNode with the XML representation for the  Rectangle
        object.

        """
        return _libsbml.Rectangle_toXML(self)

Rectangle_swigregister = _libsbml.Rectangle_swigregister
Rectangle_swigregister(Rectangle)

class RenderPoint(SBase):
    """

    [SBML 'render' package]

    A point with both absolute and relative values

    Render objects are often specified relative to the current viewport,
    i.e. we need a way to specify relative coordinate values in curves.
    For this we introduced the RenderPoint and the RenderCubicBezier class
    in the render extension.  Those two classes are used to specify curve
    and polygon elements.

    See also RenderCurve, Polygon.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RenderPoint, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, RenderPoint, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(RenderPoint self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> RenderPoint
        __init__(RenderPoint self, unsigned int level, unsigned int version) -> RenderPoint
        __init__(RenderPoint self, unsigned int level) -> RenderPoint
        __init__(RenderPoint self) -> RenderPoint
        __init__(RenderPoint self, RenderPkgNamespaces renderns) -> RenderPoint
        __init__(RenderPoint self, RenderPkgNamespaces renderns, RelAbsVector x, RelAbsVector y, RelAbsVector z) -> RenderPoint
        __init__(RenderPoint self, RenderPkgNamespaces renderns, RelAbsVector x, RelAbsVector y) -> RenderPoint
        __init__(RenderPoint self, XMLNode node, unsigned int l2version=4) -> RenderPoint
        __init__(RenderPoint self, XMLNode node) -> RenderPoint
        __init__(RenderPoint self, RenderPoint orig) -> RenderPoint


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            RenderPoint(long level = RenderExtension.getDefaultLevel(),
        long version = RenderExtension.getDefaultVersion(), long pkgVersion =
        RenderExtension.getDefaultPackageVersion())

        Creates a new RenderPoint using the given SBML Level, Version and
        "render" package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        RenderPoint.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this RenderPoint.

        Parameter 'pkgVersion' is a long integer, the SBML Render Version to
        assign to this RenderPoint.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            RenderPoint(RenderPkgNamespaces renderns, RelAbsVector x,
        RelAbsVector y, RelAbsVector z = RelAbsVector(0.0,0.0))

        Creates a new point with the given coordinates.

        Parameter 'renderns' is the RenderPkgNamespaces object. Parameter 'x'
        is x coordinate of the RenderPoint object Parameter 'y' is y
        coordinate of the RenderPoint object Parameter 'z' is z coordinate of
        the RenderPoint object If the z value is omitted, it is set to 0.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            RenderPoint( RenderPoint orig)

        Copy constructor for RenderPoint.

        Parameter 'orig' is the RenderPoint instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            RenderPoint(XMLNode node, long l2version=4)

        Creates a new RenderPoint object from the given XMLNode object. The
        XMLNode object has to contain a valid XML representation of a
        RenderPoint object as defined in the render extension specification.
        This method is normally called when render information is read from a
        file and  should normally not have to be called explicitly.

        Parameter 'node' is the XMLNode object reference that describes the
        RenderPoint object to be instantiated. Parameter 'l2version' is the
        version of SBML Level 2 to target.

        ______________________________________________________________________
        Method variant with the following signature:

            RenderPoint(RenderPkgNamespaces renderns)

        Creates a new RenderPoint using the given RenderPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'renderns' is the RenderPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_RenderPoint(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __eq__(self, left):
        """__eq__(RenderPoint self, RenderPoint left) -> bool"""
        return _libsbml.RenderPoint___eq__(self, left)


    def clone(self):
        """
        clone(RenderPoint self) -> RenderPoint


        Creates and returns a deep copy of this RenderPoint object.

        Returns a (deep) copy of this RenderPoint object.

        """
        return _libsbml.RenderPoint_clone(self)

    __swig_destroy__ = _libsbml.delete_RenderPoint
    __del__ = lambda self: None

    def initDefaults(self):
        """
        initDefaults(RenderPoint self)


        Sets the Z offset to 0.0.

        """
        return _libsbml.RenderPoint_initDefaults(self)


    def getX(self, *args):
        """
        getX(RenderPoint self) -> RelAbsVector
        getX(RenderPoint self) -> RelAbsVector


        Returns the value of the 'x' element of this RenderPoint.

        Returns the value of the 'x' element of this RenderPoint as a
        RelAbsVector.

        """
        return _libsbml.RenderPoint_getX(self, *args)


    def x(self, *args):
        """
        x(RenderPoint self) -> RelAbsVector
        x(RenderPoint self) -> RelAbsVector


        Returns the x coordinate of the RenderPoint as a  reference.

        Returns reference to x coordinate.

        """
        return _libsbml.RenderPoint_x(self, *args)


    def getY(self, *args):
        """
        getY(RenderPoint self) -> RelAbsVector
        getY(RenderPoint self) -> RelAbsVector


        Returns the value of the 'y' element of this RenderPoint.

        Returns the value of the 'y' element of this RenderPoint as a
        RelAbsVector.

        """
        return _libsbml.RenderPoint_getY(self, *args)


    def y(self, *args):
        """
        y(RenderPoint self) -> RelAbsVector
        y(RenderPoint self) -> RelAbsVector


        Returns the y coordinate of the RenderPoint as a  reference.

        Returns reference to y coordinate.

        """
        return _libsbml.RenderPoint_y(self, *args)


    def getZ(self, *args):
        """
        getZ(RenderPoint self) -> RelAbsVector
        getZ(RenderPoint self) -> RelAbsVector


        Returns the value of the 'z' element of this RenderPoint.

        Returns the value of the 'z' element of this RenderPoint as a
        RelAbsVector.

        """
        return _libsbml.RenderPoint_getZ(self, *args)


    def z(self, *args):
        """
        z(RenderPoint self) -> RelAbsVector
        z(RenderPoint self) -> RelAbsVector


        Returns the z coordinate of the RenderPoint as a  reference.

        Returns reference to z coordinate.

        """
        return _libsbml.RenderPoint_z(self, *args)


    def isSetX(self):
        """
        isSetX(RenderPoint self) -> bool


        Predicate returning 'True' if this RenderPoint's 'x' element is set.

        Returns 'True' if this RenderPoint's 'x' element has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.RenderPoint_isSetX(self)


    def isSetY(self):
        """
        isSetY(RenderPoint self) -> bool


        Predicate returning 'True' if this RenderPoint's 'y' element is set.

        Returns 'True' if this RenderPoint's 'y' element has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.RenderPoint_isSetY(self)


    def isSetZ(self):
        """
        isSetZ(RenderPoint self) -> bool


        Predicate returning 'True' if this RenderPoint's 'z' element is set.

        Returns 'True' if this RenderPoint's 'z' element has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.RenderPoint_isSetZ(self)


    def setX(self, x):
        """
        setX(RenderPoint self, RelAbsVector x) -> int


        Sets the value of the 'x' element of this RenderPoint.

        Parameter 'x' is RelAbsVector value of the 'x' element to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.RenderPoint_setX(self, x)


    def setY(self, y):
        """
        setY(RenderPoint self, RelAbsVector y) -> int


        Sets the value of the 'y' element of this RenderPoint.

        Parameter 'y' is RelAbsVector value of the 'y' element to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.RenderPoint_setY(self, y)


    def setZ(self, z):
        """
        setZ(RenderPoint self, RelAbsVector z) -> int


        Sets the value of the 'z' element of this RenderPoint.

        Parameter 'z' is RelAbsVector value of the 'z' element to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.RenderPoint_setZ(self, z)


    def setCoordinates(self, *args):
        """
        setCoordinates(RenderPoint self, RelAbsVector x, RelAbsVector y, RelAbsVector z)
        setCoordinates(RenderPoint self, RelAbsVector x, RelAbsVector y)


        Sets the coordinates of the RenderPoint to the given values.

        Parameter 'x' is x coordinate to be set. Parameter 'y' is y coordinate
        to be set. Parameter 'z' is z coordinate to be set. If the z
        coordinate is omitted, it is set to 0.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        return _libsbml.RenderPoint_setCoordinates(self, *args)


    def setOffsets(self, *args):
        """
        setOffsets(RenderPoint self, RelAbsVector x, RelAbsVector y, RelAbsVector z)
        setOffsets(RenderPoint self, RelAbsVector x, RelAbsVector y)


        Sets the coordinates of the RenderPoint to the given values. This
        method is deprecated, please use setCoordinates.

        Parameter 'x' is x coordinate to be set. Parameter 'y' is y coordinate
        to be set. Parameter 'z' is z coordinate to be set. If the z
        coordinate is omitted, it is set to 0.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        return _libsbml.RenderPoint_setOffsets(self, *args)


    def unsetX(self):
        """
        unsetX(RenderPoint self) -> int


        Unsets the value of the 'x' element of this RenderPoint.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.RenderPoint_unsetX(self)


    def unsetY(self):
        """
        unsetY(RenderPoint self) -> int


        Unsets the value of the 'y' element of this RenderPoint.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.RenderPoint_unsetY(self)


    def unsetZ(self):
        """
        unsetZ(RenderPoint self) -> int


        Unsets the value of the 'z' element of this RenderPoint.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.RenderPoint_unsetZ(self)


    def isRenderPoint(self):
        """
        isRenderPoint(RenderPoint self) -> bool


        Predicate returning 'True' if this abstract RenderPoint is of type
        RenderPoint

        Returns 'True' if this abstract RenderPoint is of type RenderPoint,
        'False' otherwise

        """
        return _libsbml.RenderPoint_isRenderPoint(self)


    def isRenderCubicBezier(self):
        """
        isRenderCubicBezier(RenderPoint self) -> bool


        Predicate returning 'True' if this abstract RenderPoint is of type
        RenderCubicBezier

        Returns 'True' if this abstract RenderPoint is of type
        RenderCubicBezier, 'False' otherwise

        """
        return _libsbml.RenderPoint_isRenderCubicBezier(self)


    def getElementName(self):
        """
        getElementName(RenderPoint self) -> string


        Returns the XML element name of this RenderPoint object.

        For RenderPoint, the XML element name is always ''element'.'

        Returns the name of this element, i.e. ''element'.'

        """
        return _libsbml.RenderPoint_getElementName(self)


    def setElementName(self, name):
        """
        setElementName(RenderPoint self, string name)


        Internal implementation method.

        """
        return _libsbml.RenderPoint_setElementName(self, name)


    def getTypeCode(self):
        """
        getTypeCode(RenderPoint self) -> int


        Returns the libSBML type code for this RenderPoint object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_RENDER_POINT.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.RenderPoint_getTypeCode(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(RenderPoint self) -> bool


        Predicate returning 'True' if all the required attributes for this
        RenderPoint object have been set.

        Returns 'True' to indicate that all the required attributes of this
        RenderPoint have been set, otherwise 'False' is returned.

        Note: The required attributes for the RenderPoint object are:

        * 'x'

        * 'y'

        """
        return _libsbml.RenderPoint_hasRequiredAttributes(self)


    def toXML(self, name):
        """
        toXML(RenderPoint self, string name) -> XMLNode


        Creates an XMLNode object from this ColorDefinition object.

        Returns the XMLNode with the XML representation for the
        ColorDefinition object.

        """
        return _libsbml.RenderPoint_toXML(self, name)

RenderPoint_swigregister = _libsbml.RenderPoint_swigregister
RenderPoint_swigregister(RenderPoint)

class RenderCubicBezier(RenderPoint):
    """

    [SBML 'render' package]

    Representation of cubic Bezier curves.

    The RenderCubicBezier is derived from RenderPoint and is the second
    element needed to represent arbitrary curves with relative coordinates
    as they can appear in RenderCurve and Polygon objects.  In addition to
    the attributes inherited from RenderPoint, RenderCubicBezier has two
    additional attributes for the two base points that define a cubic
    bezier curve.

    Segments in a RenderCurve or a Polygon are always defined by two
    consecutive RenderPoint or RenderCubicBezier elements. The first
    element in a list of RenderPoints has to be a RenderPoint object, all
    following elements can either be RenderPoint or RenderCubicBezier
    elements.  If the second element is a RenderPoint, the two elements
    represent a straight line segement; if the second element if a
    RenderCubicBezier, the two elements represent a cubic bezier curve
    segment.

    For further details please have a look at the SBML Level 3 Render
    package specification.

    """

    __swig_setmethods__ = {}
    for _s in [RenderPoint]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RenderCubicBezier, name, value)
    __swig_getmethods__ = {}
    for _s in [RenderPoint]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, RenderCubicBezier, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(RenderCubicBezier self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> RenderCubicBezier
        __init__(RenderCubicBezier self, unsigned int level, unsigned int version) -> RenderCubicBezier
        __init__(RenderCubicBezier self, unsigned int level) -> RenderCubicBezier
        __init__(RenderCubicBezier self) -> RenderCubicBezier
        __init__(RenderCubicBezier self, RenderPkgNamespaces renderns) -> RenderCubicBezier
        __init__(RenderCubicBezier self, RenderPkgNamespaces renderns, RelAbsVector bp1_x, RelAbsVector bp1_y, RelAbsVector bp1_z, RelAbsVector bp2_x, RelAbsVector bp2_y, RelAbsVector bp2_z, RelAbsVector end_x, RelAbsVector end_y, RelAbsVector end_z) -> RenderCubicBezier
        __init__(RenderCubicBezier self, XMLNode node, unsigned int l2version=4) -> RenderCubicBezier
        __init__(RenderCubicBezier self, XMLNode node) -> RenderCubicBezier
        __init__(RenderCubicBezier self, RenderCubicBezier orig) -> RenderCubicBezier


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            RenderCubicBezier(long level =
        RenderExtension.getDefaultLevel(), long version =
        RenderExtension.getDefaultVersion(), long pkgVersion =
        RenderExtension.getDefaultPackageVersion())

        Creates a new RenderCubicBezier using the given SBML Level, Version
        and "render" package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        RenderCubicBezier.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this RenderCubicBezier.

        Parameter 'pkgVersion' is a long integer, the SBML Render Version to
        assign to this RenderCubicBezier.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            RenderCubicBezier(XMLNode node, long l2version = 4)

        Creates a new RenderCubicBezier object from the given XMLNode object.
        The XMLNode object has to contain a valid XML representation of a
        RenderCubicBezier object as defined in the render extension
        specification. This method is normally called when render information
        is read from a file and should normally not have to be called
        explicitly.

        Parameter 'node' is the XMLNode object reference that describes the
        RenderCubicBezier object to be instantiated. Parameter 'l2version' is
        the version of SBML Level 2 to target.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            RenderCubicBezier(RenderPkgNamespaces renderns)

        Creates a new RenderCubicBezier using the given RenderPkgNamespaces
        object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'renderns' is the RenderPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        ______________________________________________________________________
        Method variant with the following signature:

            RenderCubicBezier(RenderCubicBezier orig)

        Copy constructor for RenderCubicBezier.

        Parameter 'orig' is the RenderCubicBezier instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            RenderCubicBezier(RenderPkgNamespaces renderns, RelAbsVector
        bp1_x, RelAbsVector bp1_y, RelAbsVector bp1_z, RelAbsVector bp2_x,
        RelAbsVector bp2_y, RelAbsVector bp2_z, RelAbsVector end_x,
        RelAbsVector end_y, RelAbsVector end_z)

        Creates a CubicBezier with the given points.

        Parameter 'renderns' is the RenderPkgNamespaces object. Parameter
        'bp1_x' is x coordinate of the first base point. Parameter 'bp1_y' is
        y coordinate of the first base point. Parameter 'bp1_z' is z
        coordinate of the first base point. Parameter 'bp2_x' is x coordinate
        of the second base point. Parameter 'bp2_y' is y coordinate of the
        second base point. Parameter 'bp2_z' is z coordinate of the second
        base point. Parameter 'end_x' is x coordinate of the end point.
        Parameter 'end_y' is y coordinate of the end point. Parameter 'end_z'
        is z coordinate of the end point.

        """
        this = _libsbml.new_RenderCubicBezier(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __eq__(self, left):
        """__eq__(RenderCubicBezier self, RenderCubicBezier left) -> bool"""
        return _libsbml.RenderCubicBezier___eq__(self, left)


    def clone(self):
        """
        clone(RenderCubicBezier self) -> RenderCubicBezier


        Creates and returns a deep copy of this RenderCubicBezier object.

        Returns a (deep) copy of this RenderCubicBezier object.

        """
        return _libsbml.RenderCubicBezier_clone(self)

    __swig_destroy__ = _libsbml.delete_RenderCubicBezier
    __del__ = lambda self: None

    def getBasePoint1_x(self, *args):
        """
        getBasePoint1_x(RenderCubicBezier self) -> RelAbsVector
        getBasePoint1_x(RenderCubicBezier self) -> RelAbsVector


        Returns the value of the 'basePoint1_x' element of this
        RenderCubicBezier.

        Returns the value of the 'basePoint1_x' element of this
        RenderCubicBezier as a RelAbsVector.

        """
        return _libsbml.RenderCubicBezier_getBasePoint1_x(self, *args)


    def basePoint1_X(self, *args):
        """
        basePoint1_X(RenderCubicBezier self) -> RelAbsVector
        basePoint1_X(RenderCubicBezier self) -> RelAbsVector


        Returns the x value of the first base point of the curve (the one
        closer to the starting point) as a  reference.

        Returns reference to x value of first base point

        """
        return _libsbml.RenderCubicBezier_basePoint1_X(self, *args)


    def getBasePoint1_y(self, *args):
        """
        getBasePoint1_y(RenderCubicBezier self) -> RelAbsVector
        getBasePoint1_y(RenderCubicBezier self) -> RelAbsVector


        Returns the value of the 'basePoint1_y' element of this
        RenderCubicBezier.

        Returns the value of the 'basePoint1_y' element of this
        RenderCubicBezier as a RelAbsVector.

        """
        return _libsbml.RenderCubicBezier_getBasePoint1_y(self, *args)


    def basePoint1_Y(self, *args):
        """
        basePoint1_Y(RenderCubicBezier self) -> RelAbsVector
        basePoint1_Y(RenderCubicBezier self) -> RelAbsVector


        Returns the y value of the first base point of the curve (the one
        closer to the starting point) as a  reference.

        Returns reference to y value of first base point

        """
        return _libsbml.RenderCubicBezier_basePoint1_Y(self, *args)


    def getBasePoint1_z(self, *args):
        """
        getBasePoint1_z(RenderCubicBezier self) -> RelAbsVector
        getBasePoint1_z(RenderCubicBezier self) -> RelAbsVector


        Returns the value of the 'basePoint1_z' element of this
        RenderCubicBezier.

        Returns the value of the 'basePoint1_z' element of this
        RenderCubicBezier as a RelAbsVector.

        """
        return _libsbml.RenderCubicBezier_getBasePoint1_z(self, *args)


    def basePoint1_Z(self, *args):
        """
        basePoint1_Z(RenderCubicBezier self) -> RelAbsVector
        basePoint1_Z(RenderCubicBezier self) -> RelAbsVector


        Returns the z value of the first base point of the curve (the one
        closer to the starting point) as a  reference.

        Returns reference to z value of first base point

        """
        return _libsbml.RenderCubicBezier_basePoint1_Z(self, *args)


    def getBasePoint2_x(self, *args):
        """
        getBasePoint2_x(RenderCubicBezier self) -> RelAbsVector
        getBasePoint2_x(RenderCubicBezier self) -> RelAbsVector


        Returns the value of the 'basePoint2_x' element of this
        RenderCubicBezier.

        Returns the value of the 'basePoint2_x' element of this
        RenderCubicBezier as a RelAbsVector.

        """
        return _libsbml.RenderCubicBezier_getBasePoint2_x(self, *args)


    def basePoint2_X(self, *args):
        """
        basePoint2_X(RenderCubicBezier self) -> RelAbsVector
        basePoint2_X(RenderCubicBezier self) -> RelAbsVector


        Returns the x value of the second base point of the curve (the one
        further from the starting point) as a  reference.

        Returns reference to x value of second base point

        """
        return _libsbml.RenderCubicBezier_basePoint2_X(self, *args)


    def getBasePoint2_y(self, *args):
        """
        getBasePoint2_y(RenderCubicBezier self) -> RelAbsVector
        getBasePoint2_y(RenderCubicBezier self) -> RelAbsVector


        Returns the value of the 'basePoint2_y' element of this
        RenderCubicBezier.

        Returns the value of the 'basePoint2_y' element of this
        RenderCubicBezier as a RelAbsVector.

        """
        return _libsbml.RenderCubicBezier_getBasePoint2_y(self, *args)


    def basePoint2_Y(self, *args):
        """
        basePoint2_Y(RenderCubicBezier self) -> RelAbsVector
        basePoint2_Y(RenderCubicBezier self) -> RelAbsVector


        Returns the y value of the second base point of the curve (the one
        further from the starting point) as a  reference.

        Returns reference to y value of second base point

        """
        return _libsbml.RenderCubicBezier_basePoint2_Y(self, *args)


    def getBasePoint2_z(self, *args):
        """
        getBasePoint2_z(RenderCubicBezier self) -> RelAbsVector
        getBasePoint2_z(RenderCubicBezier self) -> RelAbsVector


        Returns the value of the 'basePoint2_z' element of this
        RenderCubicBezier.

        Returns the value of the 'basePoint2_z' element of this
        RenderCubicBezier as a RelAbsVector.

        """
        return _libsbml.RenderCubicBezier_getBasePoint2_z(self, *args)


    def basePoint2_Z(self, *args):
        """
        basePoint2_Z(RenderCubicBezier self) -> RelAbsVector
        basePoint2_Z(RenderCubicBezier self) -> RelAbsVector


        Returns the z value of the second base point of the curve (the one
        further from the starting point) as a  reference.

        Returns reference to z value of second base point

        """
        return _libsbml.RenderCubicBezier_basePoint2_Z(self, *args)


    def isSetBasePoint1_x(self):
        """
        isSetBasePoint1_x(RenderCubicBezier self) -> bool


        Predicate returning 'True' if this RenderCubicBezier's 'basePoint1_x'
        element is set.

        Returns 'True' if this RenderCubicBezier's 'basePoint1_x' element has
        been set, otherwise 'False' is returned.

        """
        return _libsbml.RenderCubicBezier_isSetBasePoint1_x(self)


    def isSetBasePoint1_y(self):
        """
        isSetBasePoint1_y(RenderCubicBezier self) -> bool


        Predicate returning 'True' if this RenderCubicBezier's 'basePoint1_y'
        element is set.

        Returns 'True' if this RenderCubicBezier's 'basePoint1_y' element has
        been set, otherwise 'False' is returned.

        """
        return _libsbml.RenderCubicBezier_isSetBasePoint1_y(self)


    def isSetBasePoint1_z(self):
        """
        isSetBasePoint1_z(RenderCubicBezier self) -> bool


        Predicate returning 'True' if this RenderCubicBezier's 'basePoint1_z'
        element is set.

        Returns 'True' if this RenderCubicBezier's 'basePoint1_z' element has
        been set, otherwise 'False' is returned.

        """
        return _libsbml.RenderCubicBezier_isSetBasePoint1_z(self)


    def isSetBasePoint2_x(self):
        """
        isSetBasePoint2_x(RenderCubicBezier self) -> bool


        Predicate returning 'True' if this RenderCubicBezier's 'basePoint2_x'
        element is set.

        Returns 'True' if this RenderCubicBezier's 'basePoint2_x' element has
        been set, otherwise 'False' is returned.

        """
        return _libsbml.RenderCubicBezier_isSetBasePoint2_x(self)


    def isSetBasePoint2_y(self):
        """
        isSetBasePoint2_y(RenderCubicBezier self) -> bool


        Predicate returning 'True' if this RenderCubicBezier's 'basePoint2_y'
        element is set.

        Returns 'True' if this RenderCubicBezier's 'basePoint2_y' element has
        been set, otherwise 'False' is returned.

        """
        return _libsbml.RenderCubicBezier_isSetBasePoint2_y(self)


    def isSetBasePoint2_z(self):
        """
        isSetBasePoint2_z(RenderCubicBezier self) -> bool


        Predicate returning 'True' if this RenderCubicBezier's 'basePoint2_z'
        element is set.

        Returns 'True' if this RenderCubicBezier's 'basePoint2_z' element has
        been set, otherwise 'False' is returned.

        """
        return _libsbml.RenderCubicBezier_isSetBasePoint2_z(self)


    def setBasePoint1_x(self, basePoint1_x):
        """
        setBasePoint1_x(RenderCubicBezier self, RelAbsVector basePoint1_x) -> int


        Sets the value of the 'basePoint1_x' element of this
        RenderCubicBezier.

        Parameter 'basePoint1_x' is RelAbsVector value of the 'basePoint1_x'
        element to be set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.RenderCubicBezier_setBasePoint1_x(self, basePoint1_x)


    def setBasePoint1_X(self, x):
        """
        setBasePoint1_X(RenderCubicBezier self, RelAbsVector x) -> int


        Sets the x value of the first base point of the curve (the one closer
        to the starting point).

        Parameter 'x' is x coordinate of first base point.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.RenderCubicBezier_setBasePoint1_X(self, x)


    def setBasePoint1_y(self, basePoint1_y):
        """
        setBasePoint1_y(RenderCubicBezier self, RelAbsVector basePoint1_y) -> int


        Sets the value of the 'basePoint1_y' element of this
        RenderCubicBezier.

        Parameter 'basePoint1_y' is RelAbsVector value of the 'basePoint1_y'
        element to be set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.RenderCubicBezier_setBasePoint1_y(self, basePoint1_y)


    def setBasePoint1_Y(self, y):
        """
        setBasePoint1_Y(RenderCubicBezier self, RelAbsVector y) -> int


        Sets the value of the 'basePoint1_y' element of this
        RenderCubicBezier. Sets the y value of the first base point of the
        curve (the one closer to the starting point).

        Parameter 'y' is y coordinate of first base point.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.RenderCubicBezier_setBasePoint1_Y(self, y)


    def setBasePoint1_z(self, basePoint1_z):
        """
        setBasePoint1_z(RenderCubicBezier self, RelAbsVector basePoint1_z) -> int


        Sets the value of the 'basePoint1_z' element of this
        RenderCubicBezier.

        Parameter 'basePoint1_z' is RelAbsVector value of the 'basePoint1_z'
        element to be set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.RenderCubicBezier_setBasePoint1_z(self, basePoint1_z)


    def setBasePoint1_Z(self, z):
        """
        setBasePoint1_Z(RenderCubicBezier self, RelAbsVector z) -> int


        Sets the value of the 'basePoint1_z' element of this
        RenderCubicBezier. Sets the z value of the first base point of the
        curve (the one closer to the starting point).

        Parameter 'z' is z coordinate of first base point.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.RenderCubicBezier_setBasePoint1_Z(self, z)


    def setBasePoint2_x(self, basePoint2_x):
        """
        setBasePoint2_x(RenderCubicBezier self, RelAbsVector basePoint2_x) -> int


        Sets the value of the 'basePoint2_x' element of this
        RenderCubicBezier.

        Parameter 'basePoint2_x' is RelAbsVector value of the 'basePoint2_x'
        element to be set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.RenderCubicBezier_setBasePoint2_x(self, basePoint2_x)


    def setBasePoint2_X(self, x):
        """
        setBasePoint2_X(RenderCubicBezier self, RelAbsVector x) -> int


        Sets the x value of the second base point of the curve (the one
        further from the starting point).

        Parameter 'x' is value of second base point.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.RenderCubicBezier_setBasePoint2_X(self, x)


    def setBasePoint2_y(self, basePoint2_y):
        """
        setBasePoint2_y(RenderCubicBezier self, RelAbsVector basePoint2_y) -> int


        Sets the value of the 'basePoint2_y' element of this
        RenderCubicBezier.

        Parameter 'basePoint2_y' is RelAbsVector value of the 'basePoint2_y'
        element to be set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.RenderCubicBezier_setBasePoint2_y(self, basePoint2_y)


    def setBasePoint2_Y(self, y):
        """
        setBasePoint2_Y(RenderCubicBezier self, RelAbsVector y) -> int


        Sets the y value of the second base point of the curve (the one
        further from the starting point).

        Parameter 'y' is value of second base point.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.RenderCubicBezier_setBasePoint2_Y(self, y)


    def setBasePoint2_z(self, basePoint2_z):
        """
        setBasePoint2_z(RenderCubicBezier self, RelAbsVector basePoint2_z) -> int


        Sets the value of the 'basePoint2_z' element of this
        RenderCubicBezier.

        Parameter 'basePoint2_z' is RelAbsVector value of the 'basePoint2_z'
        element to be set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.RenderCubicBezier_setBasePoint2_z(self, basePoint2_z)


    def setBasePoint2_Z(self, z):
        """
        setBasePoint2_Z(RenderCubicBezier self, RelAbsVector z) -> int


        Sets the z value of the second base point of the curve (the one
        further from the starting point).

        Parameter 'z' is value of second base point.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.RenderCubicBezier_setBasePoint2_Z(self, z)


    def setBasePoint1(self, *args):
        """
        setBasePoint1(RenderCubicBezier self, RelAbsVector x, RelAbsVector y, RelAbsVector z)
        setBasePoint1(RenderCubicBezier self, RelAbsVector x, RelAbsVector y)


        Sets the first basepoint to the given coordinatees.

        Parameter 'x' is coordinate of second base point. Parameter 'y' is
        coordinate of second base point. Parameter 'z' is coordinate of second
        base point. If the z coodinate is omitted, it is set to 0.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        return _libsbml.RenderCubicBezier_setBasePoint1(self, *args)


    def setBasePoint2(self, *args):
        """
        setBasePoint2(RenderCubicBezier self, RelAbsVector x, RelAbsVector y, RelAbsVector z)
        setBasePoint2(RenderCubicBezier self, RelAbsVector x, RelAbsVector y)


        Sets the second basepoint to the given coordinatees.

        Parameter 'x' is coordinate of second base point. Parameter 'y' is
        coordinate of second base point. Parameter 'z' is coordinate of second
        base point. If the z coodinate is omitted, it is set to 0.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        """
        return _libsbml.RenderCubicBezier_setBasePoint2(self, *args)


    def unsetBasePoint1_x(self):
        """
        unsetBasePoint1_x(RenderCubicBezier self) -> int


        Unsets the value of the 'basePoint1_x' element of this
        RenderCubicBezier.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.RenderCubicBezier_unsetBasePoint1_x(self)


    def unsetBasePoint1_y(self):
        """
        unsetBasePoint1_y(RenderCubicBezier self) -> int


        Unsets the value of the 'basePoint1_y' element of this
        RenderCubicBezier.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.RenderCubicBezier_unsetBasePoint1_y(self)


    def unsetBasePoint1_z(self):
        """
        unsetBasePoint1_z(RenderCubicBezier self) -> int


        Unsets the value of the 'basePoint1_z' element of this
        RenderCubicBezier.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.RenderCubicBezier_unsetBasePoint1_z(self)


    def unsetBasePoint2_x(self):
        """
        unsetBasePoint2_x(RenderCubicBezier self) -> int


        Unsets the value of the 'basePoint2_x' element of this
        RenderCubicBezier.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.RenderCubicBezier_unsetBasePoint2_x(self)


    def unsetBasePoint2_y(self):
        """
        unsetBasePoint2_y(RenderCubicBezier self) -> int


        Unsets the value of the 'basePoint2_y' element of this
        RenderCubicBezier.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.RenderCubicBezier_unsetBasePoint2_y(self)


    def unsetBasePoint2_z(self):
        """
        unsetBasePoint2_z(RenderCubicBezier self) -> int


        Unsets the value of the 'basePoint2_z' element of this
        RenderCubicBezier.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.RenderCubicBezier_unsetBasePoint2_z(self)


    def getElementName(self):
        """
        getElementName(RenderCubicBezier self) -> string


        Returns the XML element name of this RenderCubicBezier object.

        For RenderCubicBezier, the XML element name is always ''element'.'

        Returns the name of this element, i.e. ''element'.'

        """
        return _libsbml.RenderCubicBezier_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(RenderCubicBezier self) -> int


        Returns the libSBML type code for this RenderCubicBezier object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_RENDER_CUBICBEZIER.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.RenderCubicBezier_getTypeCode(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(RenderCubicBezier self) -> bool


        Predicate returning 'True' if all the required attributes for this
        RenderCubicBezier object have been set.

        Returns 'True' to indicate that all the required attributes of this
        RenderCubicBezier have been set, otherwise 'False' is returned.

        Note: The required elements for the RenderCubicBezier object are:

        * 'basePoint1_x'

        * 'basePoint1_y'

        * 'basePoint2_x'

        * 'basePoint2_y'

        """
        return _libsbml.RenderCubicBezier_hasRequiredAttributes(self)


    def toXML(self, name):
        """
        toXML(RenderCubicBezier self, string name) -> XMLNode


        Creates an XMLNode object from this RenderCubicBezier object.

        Returns the XMLNode with the XML representation for the
        RenderCubicBezier object.

        """
        return _libsbml.RenderCubicBezier_toXML(self, name)

RenderCubicBezier_swigregister = _libsbml.RenderCubicBezier_swigregister
RenderCubicBezier_swigregister(RenderCubicBezier)

class RenderCurve(GraphicalPrimitive1D):
    """

    [SBML 'render' package]

    Representation of curves.

    The curve concept in the SBML Level 3 Render package is similar to the
    curves in the SBML layout.  Each curve consists of a number of either
    straight line segments or cubic bezier elements.  The two element
    types can also be mixed in a single curve object.

    In contrast to layout curves, render curves can not have gaps and the
    individual coordinates of the curve elements can be specified as a
    combination of absolute and relative values.

    Another difference to layout curves is the fact that render curves can
    specify decorations to be applied to the start and/or the end of the
    curve.

    Since RenderCurve is derived from GraphicalPrimitive1D, it inherits
    all its attributes and methods.

    See also LineEnding.

    """

    __swig_setmethods__ = {}
    for _s in [GraphicalPrimitive1D]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RenderCurve, name, value)
    __swig_getmethods__ = {}
    for _s in [GraphicalPrimitive1D]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, RenderCurve, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(RenderCurve self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> RenderCurve
        __init__(RenderCurve self, unsigned int level, unsigned int version) -> RenderCurve
        __init__(RenderCurve self, unsigned int level) -> RenderCurve
        __init__(RenderCurve self) -> RenderCurve
        __init__(RenderCurve self, RenderPkgNamespaces renderns) -> RenderCurve
        __init__(RenderCurve self, XMLNode node, unsigned int l2version=4) -> RenderCurve
        __init__(RenderCurve self, XMLNode node) -> RenderCurve
        __init__(RenderCurve self, RenderPkgNamespaces renderns, string id) -> RenderCurve
        __init__(RenderCurve self, RenderCurve orig) -> RenderCurve


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            RenderCurve(long level = RenderExtension.getDefaultLevel(),
        long version = RenderExtension.getDefaultVersion(), long pkgVersion =
        RenderExtension.getDefaultPackageVersion())

        Creates a new RenderCurve using the given SBML Level, Version and
        "render" package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        RenderCurve.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this RenderCurve.

        Parameter 'pkgVersion' is a long integer, the SBML Render Version to
        assign to this RenderCurve.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            RenderCurve(RenderPkgNamespaces renderns, string id)

        Instantiates an empty curve object with the given 'id'. The
        decorations  are unset and there are no curve elements.

        WARNING:

        This constructor is deprecated. The new libSBML API uses constructors
        that either take the SBML Level and Version, or take an SBMLNamespaces
        object.

        ______________________________________________________________________
        Method variant with the following signature:

            RenderCurve(XMLNode node, long l2version=4)

        Creates a new RenderCurve object from the given XMLNode object. The
        XMLNode object has to contain a valid XML representation of a
        RenderCurve object as defined in the render extension specification.
        This method is normally called when render information is read from a
        file and  should normally not have to be called explicitly.

        Parameter 'node' is the XMLNode object reference that describes the
        RenderCurve object to be instantiated. Parameter 'l2version' is the
        version of SBML Level 2 to target.

        ______________________________________________________________________
        Method variant with the following signature:

            RenderCurve(RenderPkgNamespaces renderns)

        Creates a new RenderCurve using the given RenderPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'renderns' is the RenderPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        ______________________________________________________________________
        Method variant with the following signature:

            RenderCurve(RenderCurve orig)

        Copy constructor for RenderCurve.

        Parameter 'orig' is the RenderCurve instance to copy.

        """
        this = _libsbml.new_RenderCurve(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(RenderCurve self) -> RenderCurve


        Creates and returns a deep copy of this RenderCurve object.

        Returns a (deep) copy of this RenderCurve object.

        """
        return _libsbml.RenderCurve_clone(self)

    __swig_destroy__ = _libsbml.delete_RenderCurve
    __del__ = lambda self: None

    def getStartHead(self):
        """
        getStartHead(RenderCurve self) -> string


        Returns the value of the 'startHead' attribute of this RenderCurve.

        Returns the value of the 'startHead' attribute of this RenderCurve as
        a string.

        """
        return _libsbml.RenderCurve_getStartHead(self)


    def getEndHead(self):
        """
        getEndHead(RenderCurve self) -> string


        Returns the value of the 'endHead' attribute of this RenderCurve.

        Returns the value of the 'endHead' attribute of this RenderCurve as a
        string.

        """
        return _libsbml.RenderCurve_getEndHead(self)


    def isSetStartHead(self):
        """
        isSetStartHead(RenderCurve self) -> bool


        Predicate returning 'True' if this RenderCurve's 'startHead' attribute
        is set.

        Returns 'True' if this RenderCurve's 'startHead' attribute has been
        set, otherwise 'False' is returned.

        """
        return _libsbml.RenderCurve_isSetStartHead(self)


    def isSetEndHead(self):
        """
        isSetEndHead(RenderCurve self) -> bool


        Predicate returning 'True' if this RenderCurve's 'endHead' attribute
        is set.

        Returns 'True' if this RenderCurve's 'endHead' attribute has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.RenderCurve_isSetEndHead(self)


    def setStartHead(self, startHead):
        """
        setStartHead(RenderCurve self, string startHead) -> int


        Sets the value of the 'startHead' attribute of this RenderCurve.

        Parameter 'startHead' is string& value of the 'startHead' attribute to
        be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.RenderCurve_setStartHead(self, startHead)


    def setEndHead(self, endHead):
        """
        setEndHead(RenderCurve self, string endHead) -> int


        Sets the value of the 'endHead' attribute of this RenderCurve.

        Parameter 'endHead' is string& value of the 'endHead' attribute to be
        set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.RenderCurve_setEndHead(self, endHead)


    def unsetStartHead(self):
        """
        unsetStartHead(RenderCurve self) -> int


        Unsets the value of the 'startHead' attribute of this RenderCurve.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.RenderCurve_unsetStartHead(self)


    def unsetEndHead(self):
        """
        unsetEndHead(RenderCurve self) -> int


        Unsets the value of the 'endHead' attribute of this RenderCurve.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.RenderCurve_unsetEndHead(self)


    def getListOfElements(self, *args):
        """
        getListOfElements(RenderCurve self) -> ListOfCurveElements
        getListOfElements(RenderCurve self) -> ListOfCurveElements


        Returns the ListOfCurveElements from this RenderCurve.

        Returns the ListOfCurveElements from this RenderCurve.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addElement(), getElement(), getNumElements(),
        removeElement().

        """
        return _libsbml.RenderCurve_getListOfElements(self, *args)


    def getElement(self, *args):
        """
        getElement(RenderCurve self, unsigned int n) -> RenderPoint
        getElement(RenderCurve self, unsigned int n) -> RenderPoint


        Get a RenderPoint from the RenderCurve.

        Parameter 'n' is a long integer representing the index of the
        RenderPoint to retrieve.

        Returns the nth RenderPoint in the ListOfCurveElements within this
        RenderCurve or 'None' if no such object exists.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addElement(), getNumElements(), removeElement().

        """
        return _libsbml.RenderCurve_getElement(self, *args)


    def getCurveElement(self, *args):
        """
        getCurveElement(RenderCurve self, unsigned int index) -> RenderPoint
        getCurveElement(RenderCurve self, unsigned int index) -> RenderPoint


        Returns a pointer to the curve segment with the given index or None if
        the id is invalid.

        This method call is deprecated, please use getElement instead.

        Parameter 'index' is the index of the curve element to be returned

        Returns a pointer to the curve element with the given index or None
        if the index was out of bounds.

        """
        return _libsbml.RenderCurve_getCurveElement(self, *args)


    def addElement(self, rp):
        """
        addElement(RenderCurve self, RenderPoint rp) -> int


        Adds a copy of the given RenderPoint to this RenderCurve.

        Parameter 'rp' is the RenderPoint object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_PKG_VERSION_MISMATCH

        * LIBSBML_DUPLICATE_OBJECT_ID

        Note: This method should be used with some caution.  The fact that
        this method copies the object passed to it means that the caller will
        be left holding a physically different object instance than the one
        contained inside this object.  Changes made to the original object
        instance (such as resetting attribute values) will not affect the
        instance in this object.  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 other methods on this class
        (particularly a corresponding method whose name begins with the word
        create) for alternatives that do not lead to these issues.

        See also getElement(), getNumElements(), removeElement().

        """
        return _libsbml.RenderCurve_addElement(self, rp)


    def getNumElements(self):
        """
        getNumElements(RenderCurve self) -> unsigned int


        Get the number of RenderPoint objects in this RenderCurve.

        Returns the number of RenderPoint objects in this RenderCurve.

        See also addElement(), getElement(), removeElement().

        """
        return _libsbml.RenderCurve_getNumElements(self)


    def createPoint(self):
        """
        createPoint(RenderCurve self) -> RenderPoint


        Creates a new RenderPoint object, adds it to this RenderCurve object
        and returns the RenderPoint object created.

        Returns a new RenderPoint object instance.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addElement(), getElement(), getNumElements(),
        removeElement().

        """
        return _libsbml.RenderCurve_createPoint(self)


    def createCubicBezier(self):
        """
        createCubicBezier(RenderCurve self) -> RenderCubicBezier


        Creates a new RenderCubicBezier object, adds it to this RenderCurve
        object and returns the RenderCubicBezier object created.

        Returns a new RenderCubicBezier object instance.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addElement(), getElement(), getNumElements(),
        removeElement().

        """
        return _libsbml.RenderCurve_createCubicBezier(self)


    def removeElement(self, n):
        """
        removeElement(RenderCurve self, unsigned int n) -> RenderPoint


        Removes the nth RenderPoint from this RenderCurve and returns a
        pointer to it.

        Parameter 'n' is a long integer representing the index of the
        RenderPoint to remove.

        Returns a pointer to the nth RenderPoint in this RenderCurve.

        WARNING:

        The pointer that is returned by this function is owned by the caller,
        who is responsible for deleting it.  Any changes made to the element
        will not be reflected in any resulting SBML document unless the
        element is added to an SBML Document.  Even in this case, the
        element's deletion is still the responsibility of the caller with two
        exceptions: if it is used as the 'disownedItem' in the
        ListOf.appendAndOwn() or ListOf.insertAndOwn()  functions.  All other
        functions in libsbml add a copy of the element, and do not transfer
        ownership of the pointer.

        See also addElement(), getElement(), getNumElements().

        """
        return _libsbml.RenderCurve_removeElement(self, n)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(RenderCurve self, string oldid, string newid)


        Replaces all uses of a given 'SIdRef' type attribute value with
        another value.

        In SBML, object identifiers are of a data type called SId. In SBML
        Level 3, an explicit data type called SIdRef was introduced for
        attribute values that refer to SId values; in previous Levels of SBML,
        this data type did not exist and attributes were simply described to
        as 'referring to an identifier', but the effective data type was the
        same as SIdRef in Level 3.  These and other methods of libSBML refer
        to the type SIdRef for all Levels of SBML, even if the corresponding
        SBML specification did not explicitly name the data type.

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas in MathML content, comparing the referenced
        identifiers to the value of 'oldid'.  If any matches are found, the
        matching values are replaced with 'newid'.  The method does not
        descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.RenderCurve_renameSIdRefs(self, oldid, newid)


    def getElementName(self):
        """
        getElementName(RenderCurve self) -> string


        Returns the XML element name of this RenderCurve object.

        For RenderCurve, the XML element name is always ''curve'.'

        Returns the name of this element, i.e. ''curve'.'

        """
        return _libsbml.RenderCurve_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(RenderCurve self) -> int


        Returns the libSBML type code for this RenderCurve object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_RENDER_CURVE.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.RenderCurve_getTypeCode(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(RenderCurve self) -> bool


        Predicate returning 'True' if all the required attributes for this
        RenderCurve object have been set.

        Returns 'True' to indicate that all the required attributes of this
        RenderCurve have been set, otherwise 'False' is returned.

        """
        return _libsbml.RenderCurve_hasRequiredAttributes(self)


    def hasRequiredElements(self):
        """
        hasRequiredElements(RenderCurve self) -> bool


        Predicate returning 'True' if all the required elements for this
        RenderCurve object have been set.

        Returns 'True' to indicate that all the required elements of this
        RenderCurve have been set, otherwise 'False' is returned.

        Note: The required elements for the RenderCurve object are:

        """
        return _libsbml.RenderCurve_hasRequiredElements(self)


    def connectToChild(self):
        """
        connectToChild(RenderCurve self)


        Internal implementation method.

        """
        return _libsbml.RenderCurve_connectToChild(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(RenderCurve self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.RenderCurve_enablePackageInternal(self, pkgURI, pkgPrefix, flag)


    def getElementBySId(self, id):
        """
        getElementBySId(RenderCurve self, string id) -> SBase


        Returns the first child element that has the given 'id' in the model-
        wide SId namespace, or 'None' if no such object is found.

        Parameter 'id' is a string representing the id attribute of the object
        to retrieve.

        Returns a pointer to the SBase element with the given 'id'. If no such
        object is found, this method returns 'None.'

        """
        return _libsbml.RenderCurve_getElementBySId(self, id)


    def getElementByMetaId(self, metaid):
        """
        getElementByMetaId(RenderCurve self, string metaid) -> SBase


        Returns the first child element that has the given 'metaid', or 'None'
        if no such object is found.

        Parameter 'metaid' is a string representing the metaid attribute of
        the object to retrieve.

        Returns a pointer to the SBase element with the given 'metaid'. If no
        such object is found this method returns 'None.'

        """
        return _libsbml.RenderCurve_getElementByMetaId(self, metaid)


    def toXML(self):
        """
        toXML(RenderCurve self) -> XMLNode


        Creates an XMLNode object from this RenderCurve object.

        Returns the XMLNode with the XML representation for the  RenderCurve
        object.

        """
        return _libsbml.RenderCurve_toXML(self)

RenderCurve_swigregister = _libsbml.RenderCurve_swigregister
RenderCurve_swigregister(RenderCurve)

class Polygon(GraphicalPrimitive2D):
    """

    [SBML 'render' package]

    Representation of a Polygon

    The Polygon is very similar to the RenderCurve class. The only
    difference is that in the polygon the end point of the last element in
    the curve segment list is automatically connected to the start point
    of the first element.

    Since a polygon is a closed shape and doesn't really have a start or
    an end, it does not get decorations as the RenderCurve does.  So, a
    polygon is always closed and can therefore have a fill style and fill
    style related attributes.  Those attributes are inherited from the
    Polygon base class GraphicalPrimitive2D.

    """

    __swig_setmethods__ = {}
    for _s in [GraphicalPrimitive2D]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Polygon, name, value)
    __swig_getmethods__ = {}
    for _s in [GraphicalPrimitive2D]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Polygon, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(Polygon self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> Polygon
        __init__(Polygon self, unsigned int level, unsigned int version) -> Polygon
        __init__(Polygon self, unsigned int level) -> Polygon
        __init__(Polygon self) -> Polygon
        __init__(Polygon self, RenderPkgNamespaces renderns) -> Polygon
        __init__(Polygon self, XMLNode node, unsigned int l2version=4) -> Polygon
        __init__(Polygon self, XMLNode node) -> Polygon
        __init__(Polygon self, RenderPkgNamespaces renderns, string id) -> Polygon
        __init__(Polygon self, Polygon orig) -> Polygon


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            Polygon(long level = RenderExtension.getDefaultLevel(), long
        version = RenderExtension.getDefaultVersion(), long pkgVersion =
        RenderExtension.getDefaultPackageVersion())

        Creates a new Polygon using the given SBML Level, Version and
        "render" package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        Polygon.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this Polygon.

        Parameter 'pkgVersion' is a long integer, the SBML Render Version to
        assign to this Polygon.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            Polygon(RenderPkgNamespaces renderns, string id)

        Instanciates a polygon with the given 'id' and no elements. All
        attributes inherited from GraphicalPrimitive are set as described in
        the corresponding constructor of that class (See also
        GraphicalPrimitive2D).

        Parameter 'renderns' is the SBMLNamespaces object for the SBML
        'render' package Parameter 'id' is id string for the polygon

        WARNING:

        This constructor is deprecated. The new libSBML API uses constructors
        that either take the SBML Level and Version, or take an SBMLNamespaces
        object.

        ______________________________________________________________________
        Method variant with the following signature:

            Polygon(XMLNode node, long l2version=4)

        Creates a new Polygon object from the given XMLNode object. The
        XMLNode object has to contain a valid XML representation of a  Polygon
        object as defined in the render extension specification. This method
        is normally called when render information is read from a file and
        should normally not have to be called explicitly.

        Parameter 'node' is the XMLNode object reference that describes the
        Polygon object to be instantiated.

        Parameter 'l2version' is an integer indicating the version of SBML
        Level 2

        ______________________________________________________________________
        Method variant with the following signature:

            Polygon(RenderPkgNamespaces renderns)

        Creates a new Polygon using the given RenderPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'renderns' is the RenderPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        ______________________________________________________________________
        Method variant with the following signature:

            Polygon(Polygon orig)

        Copy constructor for Polygon.

        Parameter 'orig' is the Polygon instance to copy.

        """
        this = _libsbml.new_Polygon(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(Polygon self) -> Polygon


        Creates and returns a deep copy of this Polygon object.

        Returns a (deep) copy of this Polygon object.

        """
        return _libsbml.Polygon_clone(self)

    __swig_destroy__ = _libsbml.delete_Polygon
    __del__ = lambda self: None

    def getListOfElements(self, *args):
        """
        getListOfElements(Polygon self) -> ListOfCurveElements
        getListOfElements(Polygon self) -> ListOfCurveElements


        Returns the ListOfCurveElements from this Polygon.

        Returns the ListOfCurveElements from this Polygon.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addElement(), createCubicBezier(), getElementBySId(),
        getElement(), getNumElements(), removeElement(), removeElement().

        """
        return _libsbml.Polygon_getListOfElements(self, *args)


    def getElement(self, *args):
        """
        getElement(Polygon self, unsigned int n) -> RenderPoint
        getElement(Polygon self, unsigned int n) -> RenderPoint


        Get a RenderPoint from the Polygon.

        Parameter 'n' is a long integer representing the index of the
        RenderPoint to retrieve.

        Returns the nth RenderPoint in the ListOfCurveElements within this
        Polygon or 'None' if no such object exists.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addElement(), createCubicBezier(), getElementBySId(),
        getNumElements(), removeElement(), removeElement().

        """
        return _libsbml.Polygon_getElement(self, *args)


    def addElement(self, rp):
        """
        addElement(Polygon self, RenderPoint rp) -> int


        Adds a copy of the given RenderPoint to this Polygon.

        Parameter 'rp' is the RenderPoint object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_PKG_VERSION_MISMATCH

        * LIBSBML_DUPLICATE_OBJECT_ID

        Note: This method should be used with some caution.  The fact that
        this method copies the object passed to it means that the caller will
        be left holding a physically different object instance than the one
        contained inside this object.  Changes made to the original object
        instance (such as resetting attribute values) will not affect the
        instance in this object.  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 other methods on this class
        (particularly a corresponding method whose name begins with the word
        create) for alternatives that do not lead to these issues.

        See also createCubicBezier(), getElementBySId(), getElement(),
        getNumElements(), removeElement(), removeElement().

        """
        return _libsbml.Polygon_addElement(self, rp)


    def getNumElements(self):
        """
        getNumElements(Polygon self) -> unsigned int


        Get the number of RenderPoint objects in this Polygon.

        Returns the number of RenderPoint objects in this Polygon.

        See also addElement(), createCubicBezier(), getElementBySId(),
        getElement(), removeElement(), removeElement().

        """
        return _libsbml.Polygon_getNumElements(self)


    def createPoint(self):
        """
        createPoint(Polygon self) -> RenderPoint


        Creates a new RenderPoint object, adds it to this Polygon object and
        returns the RenderPoint object created.

        Returns a new RenderPoint object instance.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addElement(), getElementBySId(), getElement(),
        getNumElements(), removeElement(), removeElement().

        """
        return _libsbml.Polygon_createPoint(self)


    def createCubicBezier(self):
        """
        createCubicBezier(Polygon self) -> RenderCubicBezier


        Creates a new RenderCubicBezier object, adds it to this Polygon object
        and returns the RenderCubicBezier object created.

        Returns a new RenderCubicBezier object instance.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addElement(), getElementBySId(), getElement(),
        getNumElements(), removeElement(), removeElement().

        """
        return _libsbml.Polygon_createCubicBezier(self)


    def removeElement(self, *args):
        """
        removeElement(Polygon self, unsigned int n) -> RenderPoint
        removeElement(Polygon self, string sid) -> RenderPoint


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeElement(long n)

        Removes the nth RenderPoint from this Polygon and returns a pointer to
        it.

        Parameter 'n' is a long integer representing the index of the
        RenderPoint to remove.

        Returns a pointer to the nth RenderPoint in this Polygon.

        WARNING:

        The pointer that is returned by this function is owned by the caller,
        who is responsible for deleting it.  Any changes made to the element
        will not be reflected in any resulting SBML document unless the
        element is added to an SBML Document.  Even in this case, the
        element's deletion is still the responsibility of the caller with two
        exceptions: if it is used as the 'disownedItem' in the
        ListOf.appendAndOwn() or ListOf.insertAndOwn()  functions.  All other
        functions in libsbml add a copy of the element, and do not transfer
        ownership of the pointer.

        See also addElement(), createCubicBezier(), getElementBySId(),
        getElement(), getNumElements(), removeElement().

        ______________________________________________________________________
        Method variant with the following signature:

            removeElement(string sid)

        Removes the RenderPoint with the given id from this  Polygon and
        returns a pointer to it.

        Parameter 'sid' is the ID of the RenderPoint to remove.

        Returns a pointer to the removed RenderPoint.

        WARNING:

        The pointer that is returned by this function is owned by the caller,
        who is responsible for deleting it.  Any changes made to the element
        will not be reflected in any resulting SBML document unless the
        element is added to an SBML Document.  Even in this case, the
        element's deletion is still the responsibility of the caller with two
        exceptions: if it is used as the 'disownedItem' in the
        ListOf.appendAndOwn() or ListOf.insertAndOwn()  functions.  All other
        functions in libsbml add a copy of the element, and do not transfer
        ownership of the pointer.

        See also addElement(), createCubicBezier(), getElementBySId(),
        getElement(), getNumElements(), removeElement().

        """
        return _libsbml.Polygon_removeElement(self, *args)


    def getElementName(self):
        """
        getElementName(Polygon self) -> string


        Returns the XML element name of this Polygon object.

        For Polygon, the XML element name is always ''polygon'.'

        Returns the name of this element, i.e. ''polygon'.'

        """
        return _libsbml.Polygon_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(Polygon self) -> int


        Returns the libSBML type code for this Polygon object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_RENDER_POLYGON.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.Polygon_getTypeCode(self)


    def connectToChild(self):
        """
        connectToChild(Polygon self)


        Internal implementation method.

        """
        return _libsbml.Polygon_connectToChild(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(Polygon self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.Polygon_enablePackageInternal(self, pkgURI, pkgPrefix, flag)


    def getElementBySId(self, id):
        """
        getElementBySId(Polygon self, string id) -> SBase


        Returns the first child element that has the given 'id' in the model-
        wide SId namespace, or 'None' if no such object is found.

        Parameter 'id' is a string representing the id attribute of the object
        to retrieve.

        Returns a pointer to the SBase element with the given 'id'. If no such
        object is found, this method returns 'None.'

        """
        return _libsbml.Polygon_getElementBySId(self, id)


    def getElementByMetaId(self, metaid):
        """
        getElementByMetaId(Polygon self, string metaid) -> SBase


        Returns the first child element that has the given 'metaid', or 'None'
        if no such object is found.

        Parameter 'metaid' is a string representing the metaid attribute of
        the object to retrieve.

        Returns a pointer to the SBase element with the given 'metaid'. If no
        such object is found this method returns 'None.'

        """
        return _libsbml.Polygon_getElementByMetaId(self, metaid)


    def toXML(self):
        """
        toXML(Polygon self) -> XMLNode


        Creates an XMLNode object from this Polygon object.

        Returns the XMLNode with the XML representation for the  Polygon
        object.

        """
        return _libsbml.Polygon_toXML(self)

Polygon_swigregister = _libsbml.Polygon_swigregister
Polygon_swigregister(Polygon)

class RenderGroup(GraphicalPrimitive2D):
    """

    [SBML 'render' package]

    A group of graphical primitives creating a composite.

    The RenderGroup concept from the SBML Level 3 Render package is used
    to to create composite representations from simple primitives. The
    RenderGroup class is derived from GraphicalPrimitive2D and inherits
    all its methods and attributes.  In addition to those, the class
    defines attributes to specify text render properties, curve
    decorations, an id, and a list of child elements which can be any
    graphical primitive or other group.

    The attributes of a group are inherited by all children of the group
    unless they specify the attribute themselves.

    See also Text, RenderCurve.

    """

    __swig_setmethods__ = {}
    for _s in [GraphicalPrimitive2D]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RenderGroup, name, value)
    __swig_getmethods__ = {}
    for _s in [GraphicalPrimitive2D]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, RenderGroup, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(RenderGroup self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> RenderGroup
        __init__(RenderGroup self, unsigned int level, unsigned int version) -> RenderGroup
        __init__(RenderGroup self, unsigned int level) -> RenderGroup
        __init__(RenderGroup self) -> RenderGroup
        __init__(RenderGroup self, RenderPkgNamespaces renderns) -> RenderGroup
        __init__(RenderGroup self, XMLNode group, unsigned int l2version=4) -> RenderGroup
        __init__(RenderGroup self, XMLNode group) -> RenderGroup
        __init__(RenderGroup self, RenderPkgNamespaces renderns, string id) -> RenderGroup
        __init__(RenderGroup self, RenderGroup orig) -> RenderGroup


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            RenderGroup(long level = RenderExtension.getDefaultLevel(),
        long version = RenderExtension.getDefaultVersion(), long pkgVersion =
        RenderExtension.getDefaultPackageVersion())

        Creates a new RenderGroup using the given SBML Level, Version and
        "render" package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        RenderGroup.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this RenderGroup.

        Parameter 'pkgVersion' is a long integer, the SBML Render Version to
        assign to this RenderGroup.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            RenderGroup(RenderPkgNamespaces renderns, string id)

        Instantiates a new RenderGroup object. All attributes are set as
        described for the default constructor of GraphicalPrimitive2D. All the
        font rendering attributes and the curve decorations are unset. The id
        is set to the given string.

        Parameter 'id' is the id for the RenderGroup object. Parameter
        'renderns' is the RenderPkgNamespaces object.

        WARNING:

        This constructor is deprecated. The new libSBML API uses constructors
        that either take the SBML Level and Version, or take an SBMLNamespaces
        object.

        ______________________________________________________________________
        Method variant with the following signature:

            RenderGroup(RenderGroup orig)

        Copy constructor for RenderGroup.

        Parameter 'orig' is the RenderGroup instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            RenderGroup(RenderPkgNamespaces renderns)

        Creates a new RenderGroup using the given RenderPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'renderns' is the RenderPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        ______________________________________________________________________
        Method variant with the following signature:

            RenderGroup(XMLNode group, long l2version=4)

        Creates a new RenderGroup object from the given XMLNode object. The
        XMLNode object has to contain a valid XML representation of a
        RenderGroup object as defined in the render extension specification.
        This method is normally called when render information is read from a
        file and  should normally not have to be called explicitly.

        Parameter 'group' is the XMLNode object reference that describes the
        RenderGroup object to be instantiated. Parameter 'l2version' is the
        version of SBML Level 2 to target.

        """
        this = _libsbml.new_RenderGroup(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(RenderGroup self) -> RenderGroup


        Creates and returns a deep copy of this RenderGroup object.

        Returns a (deep) copy of this RenderGroup object.

        """
        return _libsbml.RenderGroup_clone(self)

    __swig_destroy__ = _libsbml.delete_RenderGroup
    __del__ = lambda self: None

    def getStartHead(self):
        """
        getStartHead(RenderGroup self) -> string


        Returns the value of the 'startHead' attribute of this RenderGroup.

        Returns the value of the 'startHead' attribute of this RenderGroup as
        a string.

        """
        return _libsbml.RenderGroup_getStartHead(self)


    def getEndHead(self):
        """
        getEndHead(RenderGroup self) -> string


        Returns the value of the 'endHead' attribute of this RenderGroup.

        Returns the value of the 'endHead' attribute of this RenderGroup as a
        string.

        """
        return _libsbml.RenderGroup_getEndHead(self)


    def getFontFamily(self):
        """
        getFontFamily(RenderGroup self) -> string


        Returns the value of the 'font-family' attribute of this RenderGroup.

        Returns the value of the 'font-family' attribute of this RenderGroup
        as a string.

        """
        return _libsbml.RenderGroup_getFontFamily(self)


    def getFontWeight(self):
        """
        getFontWeight(RenderGroup self) -> int


        Returns the value of the 'font-weight' attribute of this RenderGroup.

        Returns the value of the 'font-weight' attribute of this RenderGroup
        as a FontWeight_t.

        The attribute 'font-weight' is used to specify whether  the text is
        to be 'normal' or 'bold'.  If omitted, the text may be rendered in
        either way. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'font-weight':

        * ''bold',' darker and/or thicker than normal print.

        * ''normal',' the typical print weight; lighter and/or thinner than
        'bold'.

        The possible values returned by this method are:

        * FONT_WEIGHT_BOLD

        * FONT_WEIGHT_NORMAL

        * FONT_WEIGHT_INVALID

        """
        return _libsbml.RenderGroup_getFontWeight(self)


    def getFontWeightAsString(self):
        """
        getFontWeightAsString(RenderGroup self) -> string


        Returns the value of the 'font-weight' attribute of this RenderGroup.

        Returns the value of the 'font-weight' attribute of this RenderGroup
        as a string.

        The attribute 'font-weight' is used to specify whether  the text is
        to be 'normal' or 'bold'.  If omitted, the text may be rendered in
        either way. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'font-weight':

        * ''bold',' darker and/or thicker than normal print.

        * ''normal',' the typical print weight; lighter and/or thinner than
        'bold'.

        The possible values returned by this method are:

        * ''bold''

        * ''normal''

        * ''(Unknown' FontWeight value)'

        """
        return _libsbml.RenderGroup_getFontWeightAsString(self)


    def getFontStyle(self):
        """
        getFontStyle(RenderGroup self) -> int


        Returns the value of the 'font-style' attribute of this RenderGroup.

        Returns the value of the 'font-style' attribute of this RenderGroup as
        a FontStyle_t.

        The attribute 'font-style' is used to specify whether  the text is to
        be 'normal' or 'italic'.  If omitted, the text may be rendered in
        either way. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'font-style':

        * ''italic',' slanted print

        * ''normal',' upright print

        The possible values returned by this method are:

        * FONT_STYLE_ITALIC

        * FONT_STYLE_NORMAL

        * FONT_STYLE_INVALID

        """
        return _libsbml.RenderGroup_getFontStyle(self)


    def getFontStyleAsString(self):
        """
        getFontStyleAsString(RenderGroup self) -> string


        Returns the value of the 'font-style' attribute of this RenderGroup.

        Returns the value of the 'font-style' attribute of this RenderGroup as
        a string.

        The attribute 'font-style' is used to specify whether  the text is to
        be 'normal' or 'italic'.  If omitted, the text may be rendered in
        either way. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'font-style':

        * ''italic',' slanted print

        * ''normal',' upright print

        The possible values returned by this method are:

        * ''italic''

        * ''normal''

        * ''(Unknown' FontStyle value)'

        """
        return _libsbml.RenderGroup_getFontStyleAsString(self)


    def getTextAnchor(self):
        """
        getTextAnchor(RenderGroup self) -> int


        Returns the value of the 'text-anchor' attribute of this RenderGroup.

        Returns the value of the 'text-anchor' attribute of this RenderGroup
        as a HTextAnchor_t.

        The attribute 'text-anchor' is used to specify the  horizontal
        alignment of the text.  If omitted, the text may be aligned in any
        way. In the SBML Level 3 Version 1 Render specification, the following
        are the allowable values for 'text-anchor':

        * ''start',' the start of the text is aligned to the  horizontal
        center  of the box.

        * ''middle',' the horizontal center of the text is aligned to the
        horizontal center of the box.

        * ''end',' the end of the text is aligned to the horizontal center of
        the box.

        The possible values returned by this method are:

        * H_TEXTANCHOR_START

        * H_TEXTANCHOR_MIDDLE

        * H_TEXTANCHOR_END

        * H_TEXTANCHOR_INVALID

        """
        return _libsbml.RenderGroup_getTextAnchor(self)


    def getTextAnchorAsString(self):
        """
        getTextAnchorAsString(RenderGroup self) -> string


        Returns the value of the 'text-anchor' attribute of this RenderGroup.

        Returns the value of the 'text-anchor' attribute of this RenderGroup
        as a string.

        The attribute 'text-anchor' is used to specify the  horizontal
        alignment of the text.  If omitted, the text may be aligned in any
        way. In the SBML Level 3 Version 1 Render specification, the following
        are the allowable values for 'text-anchor':

        * ''start',' the start of the text is aligned to the  horizontal
        center  of the box.

        * ''middle',' the horizontal center of the text is aligned to the
        horizontal center of the box.

        * ''end',' the end of the text is aligned to the horizontal center of
        the box.

        The possible values returned by this method are:

        * ''start''

        * ''middle''

        * ''end''

        * ''(Unknown' HTextAnchor value)'

        """
        return _libsbml.RenderGroup_getTextAnchorAsString(self)


    def getVTextAnchor(self):
        """
        getVTextAnchor(RenderGroup self) -> int


        Returns the value of the 'vtext-anchor' attribute of this RenderGroup.

        Returns the value of the 'vtext-anchor' attribute of this RenderGroup
        as a VTextAnchor_t.

        The attribute 'vtext-anchor' is used to specify the  vertical
        alignment of the text.  If omitted, the text may be aligned in any
        way. In the SBML Level 3 Version 1 Render specification, the following
        are the allowable values for 'vtext-anchor':

        * ''top',' the top of the text is aligned to the vertical center of
        the box.

        * ''middle',' the vertical center of the text is aligned with the
        vertical center of the box.

        * ''bottom',' the bottom of the text (i.e. the very bottom of any
        descending letter like 'y' or 'p') is aligned with the vertical
        center of the box.

        * ''baseline',' the baseline of the text (i.e. the bottom of any  non-
        descending letter like 'a' or e') is aligned with the vertical center
        of the box.

        The possible values returned by this method are:

        * V_TEXTANCHOR_TOP

        * V_TEXTANCHOR_MIDDLE

        * V_TEXTANCHOR_BOTTOM

        * V_TEXTANCHOR_BASELINE

        * V_TEXTANCHOR_INVALID

        """
        return _libsbml.RenderGroup_getVTextAnchor(self)


    def getVtextAnchor(self):
        """
        getVtextAnchor(RenderGroup self) -> int


        Internal implementation method.

        """
        return _libsbml.RenderGroup_getVtextAnchor(self)


    def getVTextAnchorAsString(self):
        """
        getVTextAnchorAsString(RenderGroup self) -> string


        Returns the value of the 'vtext-anchor' attribute of this RenderGroup.

        Returns the value of the 'vtext-anchor' attribute of this RenderGroup
        as a string.

        The attribute 'vtext-anchor' is used to specify the  vertical
        alignment of the text.  If omitted, the text may be aligned in any
        way. In the SBML Level 3 Version 1 Render specification, the following
        are the allowable values for 'vtext-anchor':

        * ''top',' the top of the text is aligned to the vertical center of
        the box.

        * ''middle',' the vertical center of the text is aligned with the
        vertical center of the box.

        * ''bottom',' the bottom of the text (i.e. the very bottom of any
        descending letter like 'y' or 'p') is aligned with the vertical
        center of the box.

        * ''baseline',' the baseline of the text (i.e. the bottom of any  non-
        descending letter like 'a' or e') is aligned with the vertical center
        of the box.

        The possible values returned by this method are:

        * ''top''

        * ''middle''

        * ''bottom''

        * ''baseline''

        * ''(Unknown' VTextAnchor value)'

        """
        return _libsbml.RenderGroup_getVTextAnchorAsString(self)


    def getVtextAnchorAsString(self):
        """
        getVtextAnchorAsString(RenderGroup self) -> string


        Internal implementation method.

        """
        return _libsbml.RenderGroup_getVtextAnchorAsString(self)


    def getFontSize(self, *args):
        """
        getFontSize(RenderGroup self) -> RelAbsVector
        getFontSize(RenderGroup self) -> RelAbsVector


        Returns the value of the 'font-size' element of this RenderGroup.

        Returns the value of the 'font-size' element of this RenderGroup as a
        RelAbsVector.

        """
        return _libsbml.RenderGroup_getFontSize(self, *args)


    def isSetStartHead(self):
        """
        isSetStartHead(RenderGroup self) -> bool


        Predicate returning 'True' if this RenderGroup's 'startHead' attribute
        is set.

        Returns 'True' if this RenderGroup's 'startHead' attribute has been
        set, otherwise 'False' is returned.

        """
        return _libsbml.RenderGroup_isSetStartHead(self)


    def isSetEndHead(self):
        """
        isSetEndHead(RenderGroup self) -> bool


        Predicate returning 'True' if this RenderGroup's 'endHead' attribute
        is set.

        Returns 'True' if this RenderGroup's 'endHead' attribute has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.RenderGroup_isSetEndHead(self)


    def isSetFontFamily(self):
        """
        isSetFontFamily(RenderGroup self) -> bool


        Predicate returning 'True' if this RenderGroup's 'font-family'
        attribute is set.

        Returns 'True' if this RenderGroup's 'font-family' attribute has been
        set, otherwise 'False' is returned.

        """
        return _libsbml.RenderGroup_isSetFontFamily(self)


    def isSetFontWeight(self):
        """
        isSetFontWeight(RenderGroup self) -> bool


        Predicate returning 'True' if this RenderGroup's 'font-weight'
        attribute is set.

        Returns 'True' if this RenderGroup's 'font-weight' attribute has been
        set, otherwise 'False' is returned.

        The attribute 'font-weight' is used to specify whether  the text is
        to be 'normal' or 'bold'.  If omitted, the text may be rendered in
        either way. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'font-weight':

        * ''bold',' darker and/or thicker than normal print.

        * ''normal',' the typical print weight; lighter and/or thinner than
        'bold'.

        """
        return _libsbml.RenderGroup_isSetFontWeight(self)


    def isSetFontStyle(self):
        """
        isSetFontStyle(RenderGroup self) -> bool


        Predicate returning 'True' if this RenderGroup's 'font-style'
        attribute is set.

        Returns 'True' if this RenderGroup's 'font-style' attribute has been
        set, otherwise 'False' is returned.

        The attribute 'font-style' is used to specify whether  the text is to
        be 'normal' or 'italic'.  If omitted, the text may be rendered in
        either way. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'font-style':

        * ''italic',' slanted print

        * ''normal',' upright print

        """
        return _libsbml.RenderGroup_isSetFontStyle(self)


    def isSetTextAnchor(self):
        """
        isSetTextAnchor(RenderGroup self) -> bool


        Predicate returning 'True' if this RenderGroup's 'text-anchor'
        attribute is set.

        Returns 'True' if this RenderGroup's 'text-anchor' attribute has been
        set, otherwise 'False' is returned.

        The attribute 'text-anchor' is used to specify the  horizontal
        alignment of the text.  If omitted, the text may be aligned in any
        way. In the SBML Level 3 Version 1 Render specification, the following
        are the allowable values for 'text-anchor':

        * ''start',' the start of the text is aligned to the  horizontal
        center  of the box.

        * ''middle',' the horizontal center of the text is aligned to the
        horizontal center of the box.

        * ''end',' the end of the text is aligned to the horizontal center of
        the box.

        """
        return _libsbml.RenderGroup_isSetTextAnchor(self)


    def isSetVtextAnchor(self):
        """
        isSetVtextAnchor(RenderGroup self) -> bool


        Internal implementation method.

        """
        return _libsbml.RenderGroup_isSetVtextAnchor(self)


    def isSetVTextAnchor(self):
        """
        isSetVTextAnchor(RenderGroup self) -> bool


        Predicate returning 'True' if this RenderGroup's 'vtext-anchor'
        attribute is set.

        Returns 'True' if this RenderGroup's 'vtext-anchor' attribute has been
        set, otherwise 'False' is returned.

        The attribute 'vtext-anchor' is used to specify the  vertical
        alignment of the text.  If omitted, the text may be aligned in any
        way. In the SBML Level 3 Version 1 Render specification, the following
        are the allowable values for 'vtext-anchor':

        * ''top',' the top of the text is aligned to the vertical center of
        the box.

        * ''middle',' the vertical center of the text is aligned with the
        vertical center of the box.

        * ''bottom',' the bottom of the text (i.e. the very bottom of any
        descending letter like 'y' or 'p') is aligned with the vertical
        center of the box.

        * ''baseline',' the baseline of the text (i.e. the bottom of any  non-
        descending letter like 'a' or e') is aligned with the vertical center
        of the box.

        """
        return _libsbml.RenderGroup_isSetVTextAnchor(self)


    def isSetFontSize(self):
        """
        isSetFontSize(RenderGroup self) -> bool


        Predicate returning 'True' if this RenderGroup's 'font-size' element
        is set.

        Returns 'True' if this RenderGroup's 'font-size' element has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.RenderGroup_isSetFontSize(self)


    def setStartHead(self, startHead):
        """
        setStartHead(RenderGroup self, string startHead) -> int


        Sets the value of the 'startHead' attribute of this RenderGroup.

        Parameter 'startHead' is string& value of the 'startHead' attribute to
        be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.RenderGroup_setStartHead(self, startHead)


    def setEndHead(self, endHead):
        """
        setEndHead(RenderGroup self, string endHead) -> int


        Sets the value of the 'endHead' attribute of this RenderGroup.

        Parameter 'endHead' is string& value of the 'endHead' attribute to be
        set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.RenderGroup_setEndHead(self, endHead)


    def setFontFamily(self, fontFamily):
        """
        setFontFamily(RenderGroup self, string fontFamily) -> int


        Sets the value of the 'font-family' attribute of this RenderGroup.

        Parameter 'fontFamily' is string& value of the 'font-family' attribute
        to be set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        Calling this function with 'fontFamily' = 'None' or an empty string is
        equivalent to calling unsetFontFamily().

        """
        return _libsbml.RenderGroup_setFontFamily(self, fontFamily)


    def setFontWeight(self, *args):
        """
        setFontWeight(RenderGroup self, FontWeight_t const fontWeight) -> int
        setFontWeight(RenderGroup self, Text::FONT_WEIGHT arg2) -> int
        setFontWeight(RenderGroup self, string fontWeight) -> int


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            setFontWeight( FontWeight_t fontWeight)

        Sets the value of the 'font-weight' attribute of this RenderGroup.

        Parameter 'fontWeight' is int value of the 'font-weight' attribute to
        be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        The attribute 'font-weight' is used to specify whether  the text is
        to be 'normal' or 'bold'.  If omitted, the text may be rendered in
        either way. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'font-weight':

        * ''bold',' darker and/or thicker than normal print.

        * ''normal',' the typical print weight; lighter and/or thinner than
        'bold'.

        ______________________________________________________________________
        Method variant with the following signature:

            setFontWeight(string fontWeight)

        Sets the value of the 'font-weight' attribute of this RenderGroup.

        Parameter 'fontWeight' is string& of the 'font-weight' attribute to be
        set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        The attribute 'font-weight' is used to specify whether  the text is
        to be 'normal' or 'bold'.  If omitted, the text may be rendered in
        either way. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'font-weight':

        * ''bold',' darker and/or thicker than normal print.

        * ''normal',' the typical print weight; lighter and/or thinner than
        'bold'.

        """
        return _libsbml.RenderGroup_setFontWeight(self, *args)


    def setFontStyle(self, *args):
        """
        setFontStyle(RenderGroup self, FontStyle_t const fontStyle) -> int
        setFontStyle(RenderGroup self, Text::FONT_STYLE style) -> int
        setFontStyle(RenderGroup self, string fontStyle) -> int


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            setFontStyle(string fontStyle)

        Sets the value of the 'font-style' attribute of this RenderGroup.

        Parameter 'fontStyle' is string& of the 'font-style' attribute to be
        set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        The attribute 'font-style' is used to specify whether  the text is to
        be 'normal' or 'italic'.  If omitted, the text may be rendered in
        either way. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'font-style':

        * ''italic',' slanted print

        * ''normal',' upright print

        ______________________________________________________________________
        Method variant with the following signature:

            setFontStyle( FontStyle_t fontStyle)

        Sets the value of the 'font-style' attribute of this RenderGroup.

        Parameter 'fontStyle' is int value of the 'font-style' attribute to be
        set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        The attribute 'font-style' is used to specify whether  the text is to
        be 'normal' or 'italic'.  If omitted, the text may be rendered in
        either way. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'font-style':

        * ''italic',' slanted print

        * ''normal',' upright print

        """
        return _libsbml.RenderGroup_setFontStyle(self, *args)


    def setTextAnchor(self, *args):
        """
        setTextAnchor(RenderGroup self, HTextAnchor_t const textAnchor) -> int
        setTextAnchor(RenderGroup self, Text::TEXT_ANCHOR anchor) -> int
        setTextAnchor(RenderGroup self, string textAnchor) -> int


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            setTextAnchor( HTextAnchor_t textAnchor)

        Sets the value of the 'text-anchor' attribute of this RenderGroup.

        Parameter 'textAnchor' is int value of the 'text-anchor' attribute to
        be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        The attribute 'text-anchor' is used to specify the  horizontal
        alignment of the text.  If omitted, the text may be aligned in any
        way. In the SBML Level 3 Version 1 Render specification, the following
        are the allowable values for 'text-anchor':

        * ''start',' the start of the text is aligned to the  horizontal
        center  of the box.

        * ''middle',' the horizontal center of the text is aligned to the
        horizontal center of the box.

        * ''end',' the end of the text is aligned to the horizontal center of
        the box.

        ______________________________________________________________________
        Method variant with the following signature:

            setTextAnchor(string textAnchor)

        Sets the value of the 'text-anchor' attribute of this RenderGroup.

        Parameter 'textAnchor' is string& of the 'text-anchor' attribute to be
        set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        The attribute 'text-anchor' is used to specify the  horizontal
        alignment of the text.  If omitted, the text may be aligned in any
        way. In the SBML Level 3 Version 1 Render specification, the following
        are the allowable values for 'text-anchor':

        * ''start',' the start of the text is aligned to the  horizontal
        center  of the box.

        * ''middle',' the horizontal center of the text is aligned to the
        horizontal center of the box.

        * ''end',' the end of the text is aligned to the horizontal center of
        the box.

        """
        return _libsbml.RenderGroup_setTextAnchor(self, *args)


    def setVTextAnchor(self, *args):
        """
        setVTextAnchor(RenderGroup self, Text::TEXT_ANCHOR anchor) -> int
        setVTextAnchor(RenderGroup self, string vtextAnchor) -> int
        setVTextAnchor(RenderGroup self, VTextAnchor_t const vtextAnchor) -> int


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            setVTextAnchor(string vtextAnchor)

        Sets the value of the 'vtext-anchor' attribute of this RenderGroup.

        Parameter 'vtextAnchor' is string& of the 'vtext-anchor' attribute to
        be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        The attribute 'vtext-anchor' is used to specify the  vertical
        alignment of the text.  If omitted, the text may be aligned in any
        way. In the SBML Level 3 Version 1 Render specification, the following
        are the allowable values for 'vtext-anchor':

        * ''top',' the top of the text is aligned to the vertical center of
        the box.

        * ''middle',' the vertical center of the text is aligned with the
        vertical center of the box.

        * ''bottom',' the bottom of the text (i.e. the very bottom of any
        descending letter like 'y' or 'p') is aligned with the vertical
        center of the box.

        * ''baseline',' the baseline of the text (i.e. the bottom of any  non-
        descending letter like 'a' or e') is aligned with the vertical center
        of the box.

        ______________________________________________________________________
        Method variant with the following signature:

            setVTextAnchor( VTextAnchor_t vtextAnchor)

        Sets the value of the 'vtext-anchor' attribute of this RenderGroup.

        Parameter 'vtextAnchor' is string& of the 'vtext-anchor' attribute to
        be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        The attribute 'vtext-anchor' is used to specify the  vertical
        alignment of the text.  If omitted, the text may be aligned in any
        way. In the SBML Level 3 Version 1 Render specification, the following
        are the allowable values for 'vtext-anchor':

        * ''top',' the top of the text is aligned to the vertical center of
        the box.

        * ''middle',' the vertical center of the text is aligned with the
        vertical center of the box.

        * ''bottom',' the bottom of the text (i.e. the very bottom of any
        descending letter like 'y' or 'p') is aligned with the vertical
        center of the box.

        * ''baseline',' the baseline of the text (i.e. the bottom of any  non-
        descending letter like 'a' or e') is aligned with the vertical center
        of the box.

        ______________________________________________________________________
        Method variant with the following signature:

            setVTextAnchor(Text::TEXT_ANCHOR  anchor)

        Sets the value of the 'vtext-anchor' attribute of this RenderGroup.

        Parameter 'anchor' is int value of the 'vtext-anchor' attribute to be
        set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        The attribute 'vtext-anchor' is used to specify the  vertical
        alignment of the text.  If omitted, the text may be aligned in any
        way. In the SBML Level 3 Version 1 Render specification, the following
        are the allowable values for 'vtext-anchor':

        * ''top',' the top of the text is aligned to the vertical center of
        the box.

        * ''middle',' the vertical center of the text is aligned with the
        vertical center of the box.

        * ''bottom',' the bottom of the text (i.e. the very bottom of any
        descending letter like 'y' or 'p') is aligned with the vertical
        center of the box.

        * ''baseline',' the baseline of the text (i.e. the bottom of any  non-
        descending letter like 'a' or e') is aligned with the vertical center
        of the box.

        """
        return _libsbml.RenderGroup_setVTextAnchor(self, *args)


    def setVtextAnchor(self, *args):
        """
        setVtextAnchor(RenderGroup self, Text::TEXT_ANCHOR anchor) -> int
        setVtextAnchor(RenderGroup self, string vtextAnchor) -> int
        setVtextAnchor(RenderGroup self, VTextAnchor_t const vtextAnchor) -> int
        """
        return _libsbml.RenderGroup_setVtextAnchor(self, *args)


    def setFontSize(self, size):
        """
        setFontSize(RenderGroup self, RelAbsVector size) -> int


        Sets the font size. Normally this is an absolute value, e.g. 18 for a
        18pt font. It is however allowed the specify the font size in terms of
        relative values in relation to the current viewport. In most cases the
        viewport will be the  dimensions of a bounding box of a layout object.

        Parameter 'size' is the new font size.

        """
        return _libsbml.RenderGroup_setFontSize(self, size)


    def unsetStartHead(self):
        """
        unsetStartHead(RenderGroup self) -> int


        Unsets the value of the 'startHead' attribute of this RenderGroup.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.RenderGroup_unsetStartHead(self)


    def unsetEndHead(self):
        """
        unsetEndHead(RenderGroup self) -> int


        Unsets the value of the 'endHead' attribute of this RenderGroup.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.RenderGroup_unsetEndHead(self)


    def unsetFontFamily(self):
        """
        unsetFontFamily(RenderGroup self) -> int


        Unsets the value of the 'font-family' attribute of this RenderGroup.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.RenderGroup_unsetFontFamily(self)


    def unsetFontWeight(self):
        """
        unsetFontWeight(RenderGroup self) -> int


        Unsets the value of the 'font-weight' attribute of this RenderGroup.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        The attribute 'font-weight' is used to specify whether  the text is
        to be 'normal' or 'bold'.  If omitted, the text may be rendered in
        either way. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'font-weight':

        * ''bold',' darker and/or thicker than normal print.

        * ''normal',' the typical print weight; lighter and/or thinner than
        'bold'.

        """
        return _libsbml.RenderGroup_unsetFontWeight(self)


    def unsetFontStyle(self):
        """
        unsetFontStyle(RenderGroup self) -> int


        Unsets the value of the 'font-style' attribute of this RenderGroup.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        The attribute 'font-style' is used to specify whether  the text is to
        be 'normal' or 'italic'.  If omitted, the text may be rendered in
        either way. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'font-style':

        * ''italic',' slanted print

        * ''normal',' upright print

        """
        return _libsbml.RenderGroup_unsetFontStyle(self)


    def unsetTextAnchor(self):
        """
        unsetTextAnchor(RenderGroup self) -> int


        Unsets the value of the 'text-anchor' attribute of this RenderGroup.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        The attribute 'text-anchor' is used to specify the  horizontal
        alignment of the text.  If omitted, the text may be aligned in any
        way. In the SBML Level 3 Version 1 Render specification, the following
        are the allowable values for 'text-anchor':

        * ''start',' the start of the text is aligned to the  horizontal
        center  of the box.

        * ''middle',' the horizontal center of the text is aligned to the
        horizontal center of the box.

        * ''end',' the end of the text is aligned to the horizontal center of
        the box.

        """
        return _libsbml.RenderGroup_unsetTextAnchor(self)


    def unsetVTextAnchor(self):
        """
        unsetVTextAnchor(RenderGroup self) -> int


        Unsets the value of the 'vtext-anchor' attribute of this RenderGroup.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        The attribute 'vtext-anchor' is used to specify the  vertical
        alignment of the text.  If omitted, the text may be aligned in any
        way. In the SBML Level 3 Version 1 Render specification, the following
        are the allowable values for 'vtext-anchor':

        * ''top',' the top of the text is aligned to the vertical center of
        the box.

        * ''middle',' the vertical center of the text is aligned with the
        vertical center of the box.

        * ''bottom',' the bottom of the text (i.e. the very bottom of any
        descending letter like 'y' or 'p') is aligned with the vertical
        center of the box.

        * ''baseline',' the baseline of the text (i.e. the bottom of any  non-
        descending letter like 'a' or e') is aligned with the vertical center
        of the box.

        """
        return _libsbml.RenderGroup_unsetVTextAnchor(self)


    def unsetVtextAnchor(self):
        """
        unsetVtextAnchor(RenderGroup self) -> int


        Internal implementation method.

        """
        return _libsbml.RenderGroup_unsetVtextAnchor(self)


    def unsetFontSize(self):
        """
        unsetFontSize(RenderGroup self) -> int


        Unsets the value of the 'font-size' element of this RenderGroup.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.RenderGroup_unsetFontSize(self)


    def getListOfElements(self, *args):
        """
        getListOfElements(RenderGroup self) -> ListOfDrawables
        getListOfElements(RenderGroup self) -> ListOfDrawables


        Returns the ListOfDrawables from this RenderGroup.

        Returns the ListOfDrawables from this RenderGroup.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addElement(), createEllipse(), createRectangle(),
        createPolygon(), createText(), createCurve(), createImage(),
        getElement(), getElement(), getNumElements(), removeElement(),
        removeElement().

        """
        return _libsbml.RenderGroup_getListOfElements(self, *args)


    def getElement(self, *args):
        """
        getElement(RenderGroup self, unsigned int n) -> Transformation2D
        getElement(RenderGroup self, unsigned int n) -> Transformation2D
        getElement(RenderGroup self, string id) -> Transformation2D
        getElement(RenderGroup self, string id) -> Transformation2D


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getElement(long n)

        Get a Transformation2D from the RenderGroup.

        Parameter 'n' is a long integer representing the index of the
        Transformation2D to retrieve.

        Returns the nth Transformation2D in the ListOfDrawables within this
        RenderGroup. If the index 'n' is invalid, 'None' is returned.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addElement(), createEllipse(), createRectangle(),
        createPolygon(), createText(), createCurve(), createImage(),
        getElement(), getNumElements(), removeElement(), removeElement().

        ______________________________________________________________________
        Method variant with the following signature:

            getElement(string id)

        Returns  pointer to the element with given index. If there is no such
        element, 'None' is returned. Since the id on all those object is
        optional, this routine might not be as helpful as similar routines in
        other classes.

        Parameter 'id' is id of element to be returned

        Returns pointer to element with the given 'id' or 'None' if there is
        no object with that id

        """
        return _libsbml.RenderGroup_getElement(self, *args)


    def addElement(self, td):
        """
        addElement(RenderGroup self, Transformation2D td) -> int


        Adds a copy of the given Transformation2D to this RenderGroup.

        Parameter 'td' is the Transformation2D object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_PKG_VERSION_MISMATCH

        * LIBSBML_DUPLICATE_OBJECT_ID

        Note: This method should be used with some caution.  The fact that
        this method copies the object passed to it means that the caller will
        be left holding a physically different object instance than the one
        contained inside this object.  Changes made to the original object
        instance (such as resetting attribute values) will not affect the
        instance in this object.  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 other methods on this class
        (particularly a corresponding method whose name begins with the word
        create) for alternatives that do not lead to these issues.

        See also createEllipse(), createRectangle(), createPolygon(),
        createText(), createCurve(), createImage(), getElement(),
        getElement(), getNumElements(), removeElement(), removeElement().

        """
        return _libsbml.RenderGroup_addElement(self, td)


    def addChildElement(self, pChild):
        """
        addChildElement(RenderGroup self, Transformation2D pChild) -> int


        Adds a copy of the given element to the end of the list of children
        elements.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_OPERATION_FAILED

        Note: This method should be used with some caution.  The fact that
        this method 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 RenderGroup.  Changes made to the original object
        instance (such as resetting attribute values) will not affect the
        instance in the RenderGroup.  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 RenderGroup.createXXX() for
        methods that do not lead to these issues.

        See also createEllipse(), createRectangle(), createPolygon(),
        createText(), createCurve(), createImage().

        """
        return _libsbml.RenderGroup_addChildElement(self, pChild)


    def getNumElements(self):
        """
        getNumElements(RenderGroup self) -> unsigned int


        Get the number of Transformation2D objects in this RenderGroup.

        Returns the number of Transformation2D objects in this RenderGroup.

        See also addElement(), createEllipse(), createRectangle(),
        createPolygon(), createText(), createCurve(), createImage(),
        getElement(), getElement(), removeElement(), removeElement().

        """
        return _libsbml.RenderGroup_getNumElements(self)


    def createImage(self):
        """
        createImage(RenderGroup self) -> Image


        Creates a new Image object, adds it to this RenderGroup object and
        returns the Image object created.

        Returns a new Image object instance.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addElement(), getElement(), getElement(), getNumElements(),
        removeElement(), removeElement().

        """
        return _libsbml.RenderGroup_createImage(self)


    def createEllipse(self):
        """
        createEllipse(RenderGroup self) -> Ellipse


        Creates a new Ellipse object, adds it to this RenderGroup object and
        returns the Ellipse object created.

        Returns a new Ellipse object instance.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addElement(), getElement(), getElement(), getNumElements(),
        removeElement(), removeElement().

        """
        return _libsbml.RenderGroup_createEllipse(self)


    def createRectangle(self):
        """
        createRectangle(RenderGroup self) -> Rectangle


        Creates a new Rectangle object, adds it to this RenderGroup object and
        returns the Rectangle object created.

        Returns a new Rectangle object instance.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addElement(), getElement(), getElement(), getNumElements(),
        removeElement(), removeElement().

        """
        return _libsbml.RenderGroup_createRectangle(self)


    def createPolygon(self):
        """
        createPolygon(RenderGroup self) -> Polygon


        Creates a new Polygon object, adds it to this RenderGroup object and
        returns the Polygon object created.

        Returns a new Polygon object instance.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addElement(), getElement(), getElement(), getNumElements(),
        removeElement(), removeElement().

        """
        return _libsbml.RenderGroup_createPolygon(self)


    def createGroup(self):
        """
        createGroup(RenderGroup self) -> RenderGroup


        Creates a new RenderGroup object, adds it to this RenderGroup object
        and returns the RenderGroup object created.

        Returns a new RenderGroup object instance.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addElement(), getElement(), getElement(), getNumElements(),
        removeElement(), removeElement().

        """
        return _libsbml.RenderGroup_createGroup(self)


    def createLineEnding(self):
        """
        createLineEnding(RenderGroup self) -> LineEnding


        Creates a new LineEnding object, adds it to this RenderGroup object
        and returns the LineEnding object created.

        Returns a new LineEnding object instance.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addElement(), getElement(), getElement(), getNumElements(),
        removeElement(), removeElement().

        """
        return _libsbml.RenderGroup_createLineEnding(self)


    def createText(self):
        """
        createText(RenderGroup self) -> Text


        Creates a new Text object, adds it to this RenderGroup object and
        returns the Text object created.

        Returns a new Text object instance.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addElement(), getElement(), getElement(), getNumElements(),
        removeElement(), removeElement().

        """
        return _libsbml.RenderGroup_createText(self)


    def createCurve(self):
        """
        createCurve(RenderGroup self) -> RenderCurve


        Creates a new RenderCurve object, adds it to this RenderGroup object
        and returns the RenderCurve object created.

        Returns a new RenderCurve object instance.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addElement(), getElement(), getElement(), getNumElements(),
        removeElement(), removeElement().

        """
        return _libsbml.RenderGroup_createCurve(self)


    def removeElement(self, *args):
        """
        removeElement(RenderGroup self, unsigned int n) -> Transformation2D
        removeElement(RenderGroup self, string sid) -> Transformation2D


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeElement(long n)

        Removes the nth Transformation2D from this RenderGroup and returns a
        pointer to it.

        Parameter 'n' is a long integer representing the index of the
        Transformation2D to remove.

        Returns a pointer to the nth Transformation2D in this RenderGroup.

        WARNING:

        The pointer that is returned by this function is owned by the caller,
        who is responsible for deleting it.  Any changes made to the element
        will not be reflected in any resulting SBML document unless the
        element is added to an SBML Document.  Even in this case, the
        element's deletion is still the responsibility of the caller with two
        exceptions: if it is used as the 'disownedItem' in the
        ListOf.appendAndOwn() or ListOf.insertAndOwn()  functions.  All other
        functions in libsbml add a copy of the element, and do not transfer
        ownership of the pointer.

        See also addElement(), createEllipse(), createRectangle(),
        createPolygon(), createText(), createCurve(), createImage(),
        getElement(), getElement(), getNumElements(), removeElement().

        ______________________________________________________________________
        Method variant with the following signature:

            removeElement(string sid)

        Removes the Transformation2D with the given id from this RenderGroup
        and returns a pointer to it.

        Parameter 'sid' is the ID of the Transformation2D to remove.

        Returns a pointer to the removed Transformation2D in this RenderGroup,
        or  'None' if no such Transformation2D exists.

        WARNING:

        The pointer that is returned by this function is owned by the caller,
        who is responsible for deleting it.  Any changes made to the element
        will not be reflected in any resulting SBML document unless the
        element is added to an SBML Document.  Even in this case, the
        element's deletion is still the responsibility of the caller with two
        exceptions: if it is used as the 'disownedItem' in the
        ListOf.appendAndOwn() or ListOf.insertAndOwn()  functions.  All other
        functions in libsbml add a copy of the element, and do not transfer
        ownership of the pointer.

        See also addElement(), createEllipse(), createRectangle(),
        createPolygon(), createText(), createCurve(), createImage(),
        getElement(), getElement(), getNumElements(), removeElement().

        """
        return _libsbml.RenderGroup_removeElement(self, *args)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(RenderGroup self, string oldid, string newid)


        Replaces all uses of a given 'SIdRef' type attribute value with
        another value.

        In SBML, object identifiers are of a data type called SId. In SBML
        Level 3, an explicit data type called SIdRef was introduced for
        attribute values that refer to SId values; in previous Levels of SBML,
        this data type did not exist and attributes were simply described to
        as 'referring to an identifier', but the effective data type was the
        same as SIdRef in Level 3.  These and other methods of libSBML refer
        to the type SIdRef for all Levels of SBML, even if the corresponding
        SBML specification did not explicitly name the data type.

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas in MathML content, comparing the referenced
        identifiers to the value of 'oldid'.  If any matches are found, the
        matching values are replaced with 'newid'.  The method does not
        descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.RenderGroup_renameSIdRefs(self, oldid, newid)


    def getElementName(self):
        """
        getElementName(RenderGroup self) -> string


        Returns the XML element name of this RenderGroup object.

        For RenderGroup, the XML element name is always ''g'.'

        Returns the name of this element, i.e. ''g'.'

        """
        return _libsbml.RenderGroup_getElementName(self)


    def setElementName(self, name):
        """
        setElementName(RenderGroup self, string name)


        Internal implementation method.

        """
        return _libsbml.RenderGroup_setElementName(self, name)


    def getTypeCode(self):
        """
        getTypeCode(RenderGroup self) -> int


        Returns the libSBML type code for this RenderGroup object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_RENDER_GROUP.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.RenderGroup_getTypeCode(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(RenderGroup self) -> bool


        Predicate returning 'True' if all the required attributes for this
        RenderGroup object have been set.

        Returns 'True' to indicate that all the required attributes of this
        RenderGroup have been set, otherwise 'False' is returned.

        """
        return _libsbml.RenderGroup_hasRequiredAttributes(self)


    def hasRequiredElements(self):
        """
        hasRequiredElements(RenderGroup self) -> bool


        Predicate returning 'True' if all the required elements for this
        RenderGroup object have been set.

        Returns 'True' to indicate that all the required elements of this
        RenderGroup have been set, otherwise 'False' is returned.

        Note: The required elements for the RenderGroup object are:

        """
        return _libsbml.RenderGroup_hasRequiredElements(self)


    def connectToChild(self):
        """
        connectToChild(RenderGroup self)


        Internal implementation method.

        """
        return _libsbml.RenderGroup_connectToChild(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(RenderGroup self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.RenderGroup_enablePackageInternal(self, pkgURI, pkgPrefix, flag)


    def getElementBySId(self, id):
        """
        getElementBySId(RenderGroup self, string id) -> SBase


        Returns the first child element that has the given 'id' in the model-
        wide SId namespace, or 'None' if no such object is found.

        Parameter 'id' is a string representing the id attribute of the object
        to retrieve.

        Returns a pointer to the SBase element with the given 'id'. If no such
        object is found, this method returns 'None.'

        """
        return _libsbml.RenderGroup_getElementBySId(self, id)


    def getElementByMetaId(self, metaid):
        """
        getElementByMetaId(RenderGroup self, string metaid) -> SBase


        Returns the first child element that has the given 'metaid', or 'None'
        if no such object is found.

        Parameter 'metaid' is a string representing the metaid attribute of
        the object to retrieve.

        Returns a pointer to the SBase element with the given 'metaid'. If no
        such object is found this method returns 'None.'

        """
        return _libsbml.RenderGroup_getElementByMetaId(self, metaid)


    def toXML(self):
        """
        toXML(RenderGroup self) -> XMLNode


        Creates an XMLNode object from this RenderGroup object.

        Returns the XMLNode with the XML representation for the  RenderGroup
        object.

        """
        return _libsbml.RenderGroup_toXML(self)

RenderGroup_swigregister = _libsbml.RenderGroup_swigregister
RenderGroup_swigregister(RenderGroup)

class LinearGradient(GradientBase):
    """

    [SBML 'render' package]

    Representation of a linear gradient.

    The concept of a linear gradient is more or or less taken from SVG.  A
    linear gradient is defined by a vector which determines the direction
    and the length of the gradient.  So for a valid gradient, this vector
    should have a length different from 0.  Otherwise, all restrictions
    for the GradientBase class apply.

    The vector for a linear gradient is defined by a start and an endpoint
    and each point consists of three absolute-relative value pairs.

    For examples of LinearGradient objects, see the SBML Render package
    specification and/or the SVG specification.

    See also GradientBase, RelAbsVector.

    """

    __swig_setmethods__ = {}
    for _s in [GradientBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LinearGradient, name, value)
    __swig_getmethods__ = {}
    for _s in [GradientBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, LinearGradient, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(LinearGradient self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> LinearGradient
        __init__(LinearGradient self, unsigned int level, unsigned int version) -> LinearGradient
        __init__(LinearGradient self, unsigned int level) -> LinearGradient
        __init__(LinearGradient self) -> LinearGradient
        __init__(LinearGradient self, RenderPkgNamespaces renderns) -> LinearGradient
        __init__(LinearGradient self, XMLNode node, unsigned int l2version=4) -> LinearGradient
        __init__(LinearGradient self, XMLNode node) -> LinearGradient
        __init__(LinearGradient self, RenderPkgNamespaces renderns, string id) -> LinearGradient
        __init__(LinearGradient self, LinearGradient orig) -> LinearGradient


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            LinearGradient(long level =
        RenderExtension.getDefaultLevel(), long version =
        RenderExtension.getDefaultVersion(), long pkgVersion =
        RenderExtension.getDefaultPackageVersion())

        Creates a new LinearGradient using the given SBML Level, Version and
        "render" package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        LinearGradient.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this LinearGradient.

        Parameter 'pkgVersion' is a long integer, the SBML Render Version to
        assign to this LinearGradient.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            LinearGradient(RenderPkgNamespaces renderns, string id)

        Constructor which creates a LinearGradient with no gradient stops. The
        id is set to the given value. The LinearGradient object is invalid
        until it has an id and at least two  gradient stops. The start and the
        end of the linear gradient vector are set to (0,0,0). A linear
        gradient with a vector of length zero should also be considered
        invalid.

        Parameter 'renderns' is the SBMLNamespaces object for the SBML
        'render' package Parameter 'id' is the new id for the LinearGradient.

        WARNING:

        This constructor is deprecated. The new libSBML API uses constructors
        that either take the SBML Level and Version, or take an SBMLNamespaces
        object.

        ______________________________________________________________________
        Method variant with the following signature:

            LinearGradient(XMLNode node, long l2version=4)

        Creates a new LinearGradient object from the given XMLNode object. The
        XMLNode object has to contain a valid XML representation of a
        LinearGradient object as defined in the render extension
        specification. This method is normally called when render information
        is read from a file and  should normally not have to be called
        explicitly.

        Parameter 'node' is the XMLNode object reference that describes the
        LinearGradient object to be instantiated.

        Parameter 'l2version' is an integer indicating the version of SBML
        Level 2

        ______________________________________________________________________
        Method variant with the following signature:

            LinearGradient(LinearGradient orig)

        Copy constructor for LinearGradient.

        Parameter 'orig' is the LinearGradient instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            LinearGradient(RenderPkgNamespaces renderns)

        Creates a new LinearGradient using the given RenderPkgNamespaces
        object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'renderns' is the RenderPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_LinearGradient(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(LinearGradient self) -> LinearGradient


        Creates and returns a deep copy of this LinearGradient object.

        Returns a (deep) copy of this LinearGradient object.

        """
        return _libsbml.LinearGradient_clone(self)

    __swig_destroy__ = _libsbml.delete_LinearGradient
    __del__ = lambda self: None

    def getX1(self, *args):
        """
        getX1(LinearGradient self) -> RelAbsVector
        getX1(LinearGradient self) -> RelAbsVector


        Returns the value of the 'x1' element of this LinearGradient.

        Returns the value of the 'x1' element of this LinearGradient as a
        RelAbsVector.

        """
        return _libsbml.LinearGradient_getX1(self, *args)


    def getXPoint1(self, *args):
        """
        getXPoint1(LinearGradient self) -> RelAbsVector
        getXPoint1(LinearGradient self) -> RelAbsVector


        Returns the x coordinate for the start point as a  reference.

        Returns RelAbsVector that represents the x value of the start point.

        """
        return _libsbml.LinearGradient_getXPoint1(self, *args)


    def getY1(self, *args):
        """
        getY1(LinearGradient self) -> RelAbsVector
        getY1(LinearGradient self) -> RelAbsVector


        Returns the value of the 'y1' element of this LinearGradient.

        Returns the value of the 'y1' element of this LinearGradient as a
        RelAbsVector.

        """
        return _libsbml.LinearGradient_getY1(self, *args)


    def getYPoint1(self, *args):
        """
        getYPoint1(LinearGradient self) -> RelAbsVector
        getYPoint1(LinearGradient self) -> RelAbsVector


        Returns the y coordinate for the start point as a  reference.

        Returns RelAbsVector that represents the y value of the start point.

        """
        return _libsbml.LinearGradient_getYPoint1(self, *args)


    def getZ1(self, *args):
        """
        getZ1(LinearGradient self) -> RelAbsVector
        getZ1(LinearGradient self) -> RelAbsVector


        Returns the value of the 'z1' element of this LinearGradient.

        Returns the value of the 'z1' element of this LinearGradient as a
        RelAbsVector.

        """
        return _libsbml.LinearGradient_getZ1(self, *args)


    def getZPoint1(self, *args):
        """
        getZPoint1(LinearGradient self) -> RelAbsVector
        getZPoint1(LinearGradient self) -> RelAbsVector


        Returns the z coordinate for the start point as a  reference.

        Returns RelAbsVector that represents the z value of the start point.

        """
        return _libsbml.LinearGradient_getZPoint1(self, *args)


    def getX2(self, *args):
        """
        getX2(LinearGradient self) -> RelAbsVector
        getX2(LinearGradient self) -> RelAbsVector


        Returns the value of the 'x2' element of this LinearGradient.

        Returns the value of the 'x2' element of this LinearGradient as a
        RelAbsVector.

        """
        return _libsbml.LinearGradient_getX2(self, *args)


    def getXPoint2(self, *args):
        """
        getXPoint2(LinearGradient self) -> RelAbsVector
        getXPoint2(LinearGradient self) -> RelAbsVector


        Returns the x coordinate for the end point as a  reference.

        Returns RelAbsVector that represents the x value of the end point.

        """
        return _libsbml.LinearGradient_getXPoint2(self, *args)


    def getY2(self, *args):
        """
        getY2(LinearGradient self) -> RelAbsVector
        getY2(LinearGradient self) -> RelAbsVector


        Returns the value of the 'y2' element of this LinearGradient.

        Returns the value of the 'y2' element of this LinearGradient as a
        RelAbsVector.

        """
        return _libsbml.LinearGradient_getY2(self, *args)


    def getYPoint2(self, *args):
        """
        getYPoint2(LinearGradient self) -> RelAbsVector
        getYPoint2(LinearGradient self) -> RelAbsVector


        Returns the y coordinate for the end point as a  reference.

        Returns RelAbsVector that represents the y value of the end point.

        """
        return _libsbml.LinearGradient_getYPoint2(self, *args)


    def getZ2(self, *args):
        """
        getZ2(LinearGradient self) -> RelAbsVector
        getZ2(LinearGradient self) -> RelAbsVector


        Returns the value of the 'z2' element of this LinearGradient.

        Returns the value of the 'z2' element of this LinearGradient as a
        RelAbsVector.

        """
        return _libsbml.LinearGradient_getZ2(self, *args)


    def getZPoint2(self, *args):
        """
        getZPoint2(LinearGradient self) -> RelAbsVector
        getZPoint2(LinearGradient self) -> RelAbsVector


        Returns the z coordinate for the end point as a  reference.

        Returns RelAbsVector that represents the z value of the end point.

        """
        return _libsbml.LinearGradient_getZPoint2(self, *args)


    def isSetX1(self):
        """
        isSetX1(LinearGradient self) -> bool


        Predicate returning 'True' if this LinearGradient's 'x1' element is
        set.

        Returns 'True' if this LinearGradient's 'x1' element has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.LinearGradient_isSetX1(self)


    def isSetY1(self):
        """
        isSetY1(LinearGradient self) -> bool


        Predicate returning 'True' if this LinearGradient's 'y1' element is
        set.

        Returns 'True' if this LinearGradient's 'y1' element has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.LinearGradient_isSetY1(self)


    def isSetZ1(self):
        """
        isSetZ1(LinearGradient self) -> bool


        Predicate returning 'True' if this LinearGradient's 'z1' element is
        set.

        Returns 'True' if this LinearGradient's 'z1' element has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.LinearGradient_isSetZ1(self)


    def isSetX2(self):
        """
        isSetX2(LinearGradient self) -> bool


        Predicate returning 'True' if this LinearGradient's 'x2' element is
        set.

        Returns 'True' if this LinearGradient's 'x2' element has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.LinearGradient_isSetX2(self)


    def isSetY2(self):
        """
        isSetY2(LinearGradient self) -> bool


        Predicate returning 'True' if this LinearGradient's 'y2' element is
        set.

        Returns 'True' if this LinearGradient's 'y2' element has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.LinearGradient_isSetY2(self)


    def isSetZ2(self):
        """
        isSetZ2(LinearGradient self) -> bool


        Predicate returning 'True' if this LinearGradient's 'z2' element is
        set.

        Returns 'True' if this LinearGradient's 'z2' element has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.LinearGradient_isSetZ2(self)


    def setX1(self, x1):
        """
        setX1(LinearGradient self, RelAbsVector x1) -> int


        Sets the value of the 'x1' element of this LinearGradient.

        Parameter 'x1' is RelAbsVector value of the 'x1' element to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.LinearGradient_setX1(self, x1)


    def setY1(self, y1):
        """
        setY1(LinearGradient self, RelAbsVector y1) -> int


        Sets the value of the 'y1' element of this LinearGradient.

        Parameter 'y1' is RelAbsVector value of the 'y1' element to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.LinearGradient_setY1(self, y1)


    def setZ1(self, z1):
        """
        setZ1(LinearGradient self, RelAbsVector z1) -> int


        Sets the value of the 'z1' element of this LinearGradient.

        Parameter 'z1' is RelAbsVector value of the 'z1' element to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.LinearGradient_setZ1(self, z1)


    def setX2(self, x2):
        """
        setX2(LinearGradient self, RelAbsVector x2) -> int


        Sets the value of the 'x2' element of this LinearGradient.

        Parameter 'x2' is RelAbsVector value of the 'x2' element to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.LinearGradient_setX2(self, x2)


    def setY2(self, y2):
        """
        setY2(LinearGradient self, RelAbsVector y2) -> int


        Sets the value of the 'y2' element of this LinearGradient.

        Parameter 'y2' is RelAbsVector value of the 'y2' element to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.LinearGradient_setY2(self, y2)


    def setZ2(self, z2):
        """
        setZ2(LinearGradient self, RelAbsVector z2) -> int


        Sets the value of the 'z2' element of this LinearGradient.

        Parameter 'z2' is RelAbsVector value of the 'z2' element to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.LinearGradient_setZ2(self, z2)


    def setCoordinates(self, *args):
        """
        setCoordinates(LinearGradient self, RelAbsVector x1, RelAbsVector y1, RelAbsVector z1, RelAbsVector x2, RelAbsVector y2, RelAbsVector z2)
        setCoordinates(LinearGradient self, RelAbsVector x1, RelAbsVector y1, RelAbsVector x2, RelAbsVector y2)


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            setCoordinates(RelAbsVector x1,RelAbsVector y1,RelAbsVector
        x2,RelAbsVector y2)

        Sets the 2D coordinates for the start and the end point of the linear
        gradient vector. The z values are automatically set to 0. Each value
        can be a combination of absolute and relative value and is represented
        by  a RelAbsVector object.

        Parameter 'x1' is x value of the start point of the linear gradient
        vector Parameter 'y1' is y value of the start point of the linear
        gradient vector Parameter 'x2' is x value of the end point of the
        linear gradient vector Parameter 'y2' is y value of the end point of
        the linear gradient vector

        ______________________________________________________________________
        Method variant with the following signature:

            setCoordinates(RelAbsVector x1,RelAbsVector y1,RelAbsVector
        z1,RelAbsVector x2,RelAbsVector y2,RelAbsVector z2)

        Sets the 3D coordinates for the start and the end point of the linear
        gradient vector. Each value can be a combination of absolute and
        relative value and is represented by  a RelAbsVector object.

        Parameter 'x1' is x value of the start point of the linear gradient
        vector Parameter 'y1' is y value of the start point of the linear
        gradient vector Parameter 'z1' is z value of the start point of the
        linear gradient vector Parameter 'x2' is x value of the end point of
        the linear gradient vector Parameter 'y2' is y value of the end point
        of the linear gradient vector Parameter 'z2' is z value of the end
        point of the linear gradient vector

        """
        return _libsbml.LinearGradient_setCoordinates(self, *args)


    def setPoint1(self, *args):
        """
        setPoint1(LinearGradient self, RelAbsVector x, RelAbsVector y, RelAbsVector z)
        setPoint1(LinearGradient self, RelAbsVector x, RelAbsVector y)


        Sets the coordinates for the start point of the linear gradient
        vector.

        Each value can be a combination of absolute and relative value and is
        represented by  a RelAbsVector object.

        The z value can be omitted. In that case it is set to 0.

        Parameter 'x' is x value of the start point of the linear gradient
        vector Parameter 'y' is y value of the start point of the linear
        gradient vector Parameter 'z' is z value of the start point of the
        linear gradient vector

        """
        return _libsbml.LinearGradient_setPoint1(self, *args)


    def setPoint2(self, *args):
        """
        setPoint2(LinearGradient self, RelAbsVector x, RelAbsVector y, RelAbsVector z)
        setPoint2(LinearGradient self, RelAbsVector x, RelAbsVector y)


        Sets the coordinates for the end point of the linear gradient vector.

        Each value can be a combination of absolute and relative value and is
        represented by  a RelAbsVector object.

        The z value can be omitted. In that case it is set to 0.

        Parameter 'x' is x value of the end point of the linear gradient
        vector Parameter 'y' is y value of the end point of the linear
        gradient vector Parameter 'z' is z value of the end point of the
        linear gradient vector

        """
        return _libsbml.LinearGradient_setPoint2(self, *args)


    def unsetX1(self):
        """
        unsetX1(LinearGradient self) -> int


        Unsets the value of the 'x1' element of this LinearGradient.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.LinearGradient_unsetX1(self)


    def unsetY1(self):
        """
        unsetY1(LinearGradient self) -> int


        Unsets the value of the 'y1' element of this LinearGradient.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.LinearGradient_unsetY1(self)


    def unsetZ1(self):
        """
        unsetZ1(LinearGradient self) -> int


        Unsets the value of the 'z1' element of this LinearGradient.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.LinearGradient_unsetZ1(self)


    def unsetX2(self):
        """
        unsetX2(LinearGradient self) -> int


        Unsets the value of the 'x2' element of this LinearGradient.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.LinearGradient_unsetX2(self)


    def unsetY2(self):
        """
        unsetY2(LinearGradient self) -> int


        Unsets the value of the 'y2' element of this LinearGradient.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.LinearGradient_unsetY2(self)


    def unsetZ2(self):
        """
        unsetZ2(LinearGradient self) -> int


        Unsets the value of the 'z2' element of this LinearGradient.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.LinearGradient_unsetZ2(self)


    def getElementName(self):
        """
        getElementName(LinearGradient self) -> string


        Returns the XML element name of this LinearGradient object.

        For LinearGradient, the XML element name is always ''linearGradient'.'

        Returns the name of this element, i.e. ''linearGradient'.'

        """
        return _libsbml.LinearGradient_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(LinearGradient self) -> int


        Returns the libSBML type code for this LinearGradient object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object:
        SBML_RENDER_LINEARGRADIENT.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.LinearGradient_getTypeCode(self)


    def toXML(self):
        """
        toXML(LinearGradient self) -> XMLNode


        Creates an XMLNode object from this LinearGradient object.

        Returns the XMLNode with the XML representation for the
        LinearGradient object.

        """
        return _libsbml.LinearGradient_toXML(self)

LinearGradient_swigregister = _libsbml.LinearGradient_swigregister
LinearGradient_swigregister(LinearGradient)

class LineEnding(GraphicalPrimitive2D):
    """

    [SBML 'render' package]

    Decoration element for the start and/or end of curves.

    LineEndings in the SBML Level 3 Render package are used to apply
    certain decorations to the end of curves. Since many curves in layout
    diagrams use the same decoration for the beginnings and start of a
    line, it would be highly redundant to encode those decorations with
    each line. Therefore, LineEnding objects can be defined which are then
    applied to the beginning or the ends of several curve objects.

    A LineEnding contains an id by which it can be referenced from curve
    styles, it contains a visual representation of the decoration in the
    form of a render extension Group object and it has some attributes
    that define the viewport and how the LineEnding is to be applied to a
    curve.

    A LineEnding object is only valid if it has an id, a viewport that has
    an area which is not 0 and a valid group object.

    """

    __swig_setmethods__ = {}
    for _s in [GraphicalPrimitive2D]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LineEnding, name, value)
    __swig_getmethods__ = {}
    for _s in [GraphicalPrimitive2D]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, LineEnding, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(LineEnding self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> LineEnding
        __init__(LineEnding self, unsigned int level, unsigned int version) -> LineEnding
        __init__(LineEnding self, unsigned int level) -> LineEnding
        __init__(LineEnding self) -> LineEnding
        __init__(LineEnding self, RenderPkgNamespaces renderns) -> LineEnding
        __init__(LineEnding self, XMLNode node, unsigned int l2version) -> LineEnding
        __init__(LineEnding self, RenderPkgNamespaces renderns, string id) -> LineEnding
        __init__(LineEnding self, LineEnding orig) -> LineEnding


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            LineEnding(long level = RenderExtension.getDefaultLevel(),
        long version = RenderExtension.getDefaultVersion(), long pkgVersion =
        RenderExtension.getDefaultPackageVersion())

        Creates a new LineEnding using the given SBML Level, Version and
        "render" package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        LineEnding.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this LineEnding.

        Parameter 'pkgVersion' is a long integer, the SBML Render Version to
        assign to this LineEnding.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            LineEnding(XMLNode node, long l2version)

        Creates a new LineEnding object from the given XMLNode object. The
        XMLNode object has to contain a valid XML representation of a
        LineEnding object as defined in the render extension specification.
        This method is normally called when render information is read from a
        file and  should normally not have to be called explicitly.

        Parameter 'node' is the XMLNode object reference that describes the
        LineEnding object to be instantiated.

        Parameter 'l2version' is The version of SBML Level 2.

        ______________________________________________________________________
        Method variant with the following signature:

            LineEnding(RenderPkgNamespaces renderns, string id)

        Constructor which creates a LineEnding with an empty group object, and
        a viewport with a size of 0. The id is set to the given value. In
        order to get a valid object, the group object has to be valid, the
        group object has to have descendants other than groups and the
        viewport has to have a positive size.

        Parameter 'renderns' is the SBMLNamespaces object for the SBML
        'render' package Parameter 'id' is The id for the LineEnding.

        WARNING:

        This constructor is deprecated. The new libSBML API uses constructors
        that either take the SBML Level and Version, or take an SBMLNamespaces
        object.

        ______________________________________________________________________
        Method variant with the following signature:

            LineEnding(RenderPkgNamespaces renderns)

        Creates a new LineEnding using the given RenderPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'renderns' is the RenderPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        ______________________________________________________________________
        Method variant with the following signature:

            LineEnding(LineEnding orig)

        Copy constructor for LineEnding.

        Parameter 'orig' is the LineEnding instance to copy.

        """
        this = _libsbml.new_LineEnding(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(LineEnding self) -> LineEnding


        Creates and returns a deep copy of this LineEnding object.

        Returns a (deep) copy of this LineEnding object.

        """
        return _libsbml.LineEnding_clone(self)

    __swig_destroy__ = _libsbml.delete_LineEnding
    __del__ = lambda self: None

    def getId(self):
        """
        getId(LineEnding self) -> string


        Returns the value of the 'id' attribute of this LineEnding.

        Returns the value of the 'id' attribute of this LineEnding as a
        string.

        """
        return _libsbml.LineEnding_getId(self)


    def getEnableRotationalMapping(self):
        """
        getEnableRotationalMapping(LineEnding self) -> bool


        Returns the value of the 'enableRotationalMapping' attribute of this
        LineEnding.

        Returns the value of the 'enableRotationalMapping' attribute of this
        LineEnding as a boolean.

        """
        return _libsbml.LineEnding_getEnableRotationalMapping(self)


    def getIsEnabledRotationalMapping(self):
        """
        getIsEnabledRotationalMapping(LineEnding self) -> bool


        Returns whether rotational mapping is enabled or not.

        Returns bool value that specifies if rotational mapping is  enabled
        for the LineEnding or not.

        """
        return _libsbml.LineEnding_getIsEnabledRotationalMapping(self)


    def isSetId(self):
        """
        isSetId(LineEnding self) -> bool


        Predicate returning 'True' if this LineEnding's 'id' attribute is set.

        Returns 'True' if this LineEnding's 'id' attribute has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.LineEnding_isSetId(self)


    def isSetEnableRotationalMapping(self):
        """
        isSetEnableRotationalMapping(LineEnding self) -> bool


        Predicate returning 'True' if this LineEnding's
        'enableRotationalMapping' attribute is set.

        Returns 'True' if this LineEnding's 'enableRotationalMapping'
        attribute has been set, otherwise 'False' is returned.

        """
        return _libsbml.LineEnding_isSetEnableRotationalMapping(self)


    def setId(self, id):
        """
        setId(LineEnding self, string id) -> int


        Sets the value of the 'id' attribute of this LineEnding.

        Parameter 'id' is string& value of the 'id' attribute to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        Calling this function with 'id' = 'None' or an empty string is
        equivalent to calling unsetId().

        """
        return _libsbml.LineEnding_setId(self, id)


    def setEnableRotationalMapping(self, enableRotationalMapping):
        """
        setEnableRotationalMapping(LineEnding self, bool enableRotationalMapping) -> int


        Sets the value of the 'enableRotationalMapping' attribute of this
        LineEnding.

        Parameter 'enableRotationalMapping' is bool value of the
        'enableRotationalMapping' attribute to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.LineEnding_setEnableRotationalMapping(self, enableRotationalMapping)


    def unsetId(self):
        """
        unsetId(LineEnding self) -> int


        Unsets the value of the 'id' attribute of this LineEnding.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.LineEnding_unsetId(self)


    def unsetEnableRotationalMapping(self):
        """
        unsetEnableRotationalMapping(LineEnding self) -> int


        Unsets the value of the 'enableRotationalMapping' attribute of this
        LineEnding.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.LineEnding_unsetEnableRotationalMapping(self)


    def getGroup(self, *args):
        """
        getGroup(LineEnding self) -> RenderGroup
        getGroup(LineEnding self) -> RenderGroup


        Returns the value of the 'group' element of this LineEnding.

        Returns the value of the 'group' element of this LineEnding as a
        RenderGroup.

        """
        return _libsbml.LineEnding_getGroup(self, *args)


    def getBoundingBox(self, *args):
        """
        getBoundingBox(LineEnding self) -> BoundingBox
        getBoundingBox(LineEnding self) -> BoundingBox


        Returns the value of the 'boundingBox' element of this LineEnding.

        Returns the value of the 'boundingBox' element of this LineEnding as a
        BoundingBox.

        """
        return _libsbml.LineEnding_getBoundingBox(self, *args)


    def isSetGroup(self):
        """
        isSetGroup(LineEnding self) -> bool


        Predicate returning 'True' if this LineEnding's 'group' element is
        set.

        Returns 'True' if this LineEnding's 'group' element has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.LineEnding_isSetGroup(self)


    def isSetBoundingBox(self):
        """
        isSetBoundingBox(LineEnding self) -> bool


        Predicate returning 'True' if this LineEnding's 'boundingBox' element
        is set.

        Returns 'True' if this LineEnding's 'boundingBox' element has been
        set, otherwise 'False' is returned.

        """
        return _libsbml.LineEnding_isSetBoundingBox(self)


    def setGroup(self, group):
        """
        setGroup(LineEnding self, RenderGroup group) -> int


        Sets the value of the 'group' element of this LineEnding.

        Parameter 'group' is RenderGroup value of the 'group' element to be
        set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.LineEnding_setGroup(self, group)


    def setBoundingBox(self, boundingBox):
        """
        setBoundingBox(LineEnding self, BoundingBox boundingBox) -> int


        Sets the value of the 'boundingBox' element of this LineEnding.

        Parameter 'boundingBox' is BoundingBox value of the 'boundingBox'
        element to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.LineEnding_setBoundingBox(self, boundingBox)


    def createGroup(self):
        """
        createGroup(LineEnding self) -> RenderGroup


        Creates a new RenderGroup object, adds it to this LineEnding object
        and returns the RenderGroup object created.

        Returns a new RenderGroup object instance.

        """
        return _libsbml.LineEnding_createGroup(self)


    def createBoundingBox(self):
        """
        createBoundingBox(LineEnding self) -> BoundingBox


        Creates a new BoundingBox object, adds it to this LineEnding object
        and returns the BoundingBox object created.

        Returns a new BoundingBox object instance.

        """
        return _libsbml.LineEnding_createBoundingBox(self)


    def unsetGroup(self):
        """
        unsetGroup(LineEnding self) -> int


        Unsets the value of the 'group' element of this LineEnding.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.LineEnding_unsetGroup(self)


    def unsetBoundingBox(self):
        """
        unsetBoundingBox(LineEnding self) -> int


        Unsets the value of the 'boundingBox' element of this LineEnding.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.LineEnding_unsetBoundingBox(self)


    def getElementName(self):
        """
        getElementName(LineEnding self) -> string


        Returns the XML element name of this LineEnding object.

        For LineEnding, the XML element name is always ''lineEnding'.'

        Returns the name of this element, i.e. ''lineEnding'.'

        """
        return _libsbml.LineEnding_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(LineEnding self) -> int


        Returns the libSBML type code for this LineEnding object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_RENDER_LINEENDING.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.LineEnding_getTypeCode(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(LineEnding self) -> bool


        Predicate returning 'True' if all the required attributes for this
        LineEnding object have been set.

        Returns 'True' to indicate that all the required attributes of this
        LineEnding have been set, otherwise 'False' is returned.

        Note: The required attributes for the LineEnding object are:

        * 'id'

        """
        return _libsbml.LineEnding_hasRequiredAttributes(self)


    def hasRequiredElements(self):
        """
        hasRequiredElements(LineEnding self) -> bool


        Predicate returning 'True' if all the required elements for this
        LineEnding object have been set.

        Returns 'True' to indicate that all the required elements of this
        LineEnding have been set, otherwise 'False' is returned.

        Note: The required elements for the LineEnding object are:

        """
        return _libsbml.LineEnding_hasRequiredElements(self)


    def connectToChild(self):
        """
        connectToChild(LineEnding self)


        Internal implementation method.

        """
        return _libsbml.LineEnding_connectToChild(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(LineEnding self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.LineEnding_enablePackageInternal(self, pkgURI, pkgPrefix, flag)


    def getElementBySId(self, id):
        """
        getElementBySId(LineEnding self, string id) -> SBase


        Returns the first child element that has the given 'id' in the model-
        wide SId namespace, or 'None' if no such object is found.

        Parameter 'id' is a string representing the id attribute of the object
        to retrieve.

        Returns a pointer to the SBase element with the given 'id'. If no such
        object is found, this method returns 'None.'

        """
        return _libsbml.LineEnding_getElementBySId(self, id)


    def getElementByMetaId(self, metaid):
        """
        getElementByMetaId(LineEnding self, string metaid) -> SBase


        Returns the first child element that has the given 'metaid', or 'None'
        if no such object is found.

        Parameter 'metaid' is a string representing the metaid attribute of
        the object to retrieve.

        Returns a pointer to the SBase element with the given 'metaid'. If no
        such object is found this method returns 'None.'

        """
        return _libsbml.LineEnding_getElementByMetaId(self, metaid)


    def toXML(self):
        """
        toXML(LineEnding self) -> XMLNode


        Creates an XMLNode object from this LineEnding object.

        Returns the XMLNode with the XML representation for the  LineEnding
        object.

        """
        return _libsbml.LineEnding_toXML(self)

LineEnding_swigregister = _libsbml.LineEnding_swigregister
LineEnding_swigregister(LineEnding)

class LocalRenderInformation(RenderInformationBase):
    """

    [SBML 'render' package]

    Rendering information stored in Layouts.

    LocalRenderInformation is one of the subclasses of
    RenderInformationBase. A 'local rendering information' object contains
    color definitions, gradient definitions and line endings as defined in
    RenderInformationBase.  Additionally it has a list of local styles
    which specifies type, role and id based render information.  Local
    render information can specify id based render information because it
    does belong to a certain layout and it can reference ids of object in
    that layout.

    """

    __swig_setmethods__ = {}
    for _s in [RenderInformationBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LocalRenderInformation, name, value)
    __swig_getmethods__ = {}
    for _s in [RenderInformationBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, LocalRenderInformation, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(LocalRenderInformation self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> LocalRenderInformation
        __init__(LocalRenderInformation self, unsigned int level, unsigned int version) -> LocalRenderInformation
        __init__(LocalRenderInformation self, unsigned int level) -> LocalRenderInformation
        __init__(LocalRenderInformation self) -> LocalRenderInformation
        __init__(LocalRenderInformation self, RenderPkgNamespaces renderns) -> LocalRenderInformation
        __init__(LocalRenderInformation self, RenderPkgNamespaces renderns, string id) -> LocalRenderInformation
        __init__(LocalRenderInformation self, LocalRenderInformation orig) -> LocalRenderInformation


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            LocalRenderInformation(long level =
        RenderExtension.getDefaultLevel(), long version =
        RenderExtension.getDefaultVersion(), long pkgVersion =
        RenderExtension.getDefaultPackageVersion())

        Creates a new LocalRenderInformation using the given SBML Level,
        Version and "render" package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        LocalRenderInformation.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this LocalRenderInformation.

        Parameter 'pkgVersion' is a long integer, the SBML Render Version to
        assign to this LocalRenderInformation.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            LocalRenderInformation(LocalRenderInformation orig)

        Copy constructor for LocalRenderInformation.

        Parameter 'orig' is the LocalRenderInformation instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            LocalRenderInformation(RenderPkgNamespaces renderns, string
        id)

        Constructor which creates a LocalRenderInformation with the given 'id'
        and all lists empty.

        Parameter 'renderns' is the SBMLNamespaces object for the SBML
        'render' package Parameter 'id' is the new id for the
        LocalRenderInformation.

        WARNING:

        This constructor is deprecated. The new libSBML API uses constructors
        that either take the SBML Level and Version, or take an SBMLNamespaces
        object.

        ______________________________________________________________________
        Method variant with the following signature:

            LocalRenderInformation(RenderPkgNamespaces renderns)

        Creates a new LocalRenderInformation using the given
        RenderPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'renderns' is the RenderPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_LocalRenderInformation(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(LocalRenderInformation self) -> LocalRenderInformation


        Creates and returns a deep copy of this LocalRenderInformation object.

        Returns a (deep) copy of this LocalRenderInformation object.

        """
        return _libsbml.LocalRenderInformation_clone(self)

    __swig_destroy__ = _libsbml.delete_LocalRenderInformation
    __del__ = lambda self: None

    def getListOfLocalStyles(self, *args):
        """
        getListOfLocalStyles(LocalRenderInformation self) -> ListOfLocalStyles
        getListOfLocalStyles(LocalRenderInformation self) -> ListOfLocalStyles


        Returns the ListOfLocalStyles from this LocalRenderInformation.

        Returns the ListOfLocalStyles from this LocalRenderInformation.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addLocalStyle(), createLocalStyle(), getLocalStyle(),
        getLocalStyle(), getNumLocalStyles(), removeLocalStyle(),
        removeLocalStyle().

        """
        return _libsbml.LocalRenderInformation_getListOfLocalStyles(self, *args)


    def getListOfStyles(self, *args):
        """
        getListOfStyles(LocalRenderInformation self) -> ListOfLocalStyles
        getListOfStyles(LocalRenderInformation self) -> ListOfLocalStyles


        Returns the ListOfLocalStyles from this LocalRenderInformation.

        Returns the ListOfLocalStyles from this LocalRenderInformation.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addLocalStyle(), createLocalStyle(), getLocalStyle(),
        getLocalStyle(), getNumLocalStyles(), removeLocalStyle(),
        removeLocalStyle().

        """
        return _libsbml.LocalRenderInformation_getListOfStyles(self, *args)


    def getLocalStyle(self, *args):
        """
        getLocalStyle(LocalRenderInformation self, unsigned int n) -> LocalStyle
        getLocalStyle(LocalRenderInformation self, unsigned int n) -> LocalStyle
        getLocalStyle(LocalRenderInformation self, string id) -> LocalStyle
        getLocalStyle(LocalRenderInformation self, string id) -> LocalStyle


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getLocalStyle(long n)

        Get a LocalStyle from the LocalRenderInformation.

        Parameter 'n' is a long integer representing the index of the
        LocalStyle to retrieve.

        Returns the nth LocalStyle in the ListOfLocalStyles within this
        LocalRenderInformation. If the index 'n' is invalid, 'None' is
        returned.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addLocalStyle(), createLocalStyle(), getLocalStyle(),
        getNumLocalStyles(), removeLocalStyle(), removeLocalStyle().

        ______________________________________________________________________
        Method variant with the following signature:

            getLocalStyle(string id)

        Returns a pointer to the style with the given 'id'. If the id is
        invalid, 'None' is returned.

        Parameter 'id' is id of the LocalStyle to be returned.

        Returns pointer to the style with the given 'id' or 'None'

        """
        return _libsbml.LocalRenderInformation_getLocalStyle(self, *args)


    def getStyle(self, *args):
        """
        getStyle(LocalRenderInformation self, unsigned int n) -> LocalStyle
        getStyle(LocalRenderInformation self, unsigned int n) -> LocalStyle
        getStyle(LocalRenderInformation self, string id) -> LocalStyle
        getStyle(LocalRenderInformation self, string id) -> LocalStyle


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            getStyle(long n)

        Get a LocalStyle from the LocalRenderInformation.

        Parameter 'n' is a long integer representing the index of the
        LocalStyle to retrieve.

        Returns the nth LocalStyle in the ListOfLocalStyles within this
        LocalRenderInformation. If the index 'n' is invalid, 'None' is
        returned.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addStyle(), createLocalStyle(), getStyle(), getNumStyles(),
        removeStyle(), removeStyle().

        ______________________________________________________________________
        Method variant with the following signature:

            getStyle(string id)

        Returns a pointer to the style with the given 'id'. If the id is
        invalid, 'None' is returned.

        Parameter 'id' is id of the LocalStyle to be returned.

        Returns pointer to the style with the given 'id' or 'None'

        """
        return _libsbml.LocalRenderInformation_getStyle(self, *args)


    def addLocalStyle(self, ls):
        """
        addLocalStyle(LocalRenderInformation self, LocalStyle ls) -> int


        Adds a copy of the given LocalStyle to this LocalRenderInformation.

        Parameter 'ls' is the LocalStyle object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_PKG_VERSION_MISMATCH

        * LIBSBML_DUPLICATE_OBJECT_ID

        Note: This method should be used with some caution.  The fact that
        this method copies the object passed to it means that the caller will
        be left holding a physically different object instance than the one
        contained inside this object.  Changes made to the original object
        instance (such as resetting attribute values) will not affect the
        instance in this object.  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 other methods on this class
        (particularly a corresponding method whose name begins with the word
        create) for alternatives that do not lead to these issues.

        See also createLocalStyle(), getLocalStyle(), getLocalStyle(),
        getNumLocalStyles(), removeLocalStyle(), removeLocalStyle().

        """
        return _libsbml.LocalRenderInformation_addLocalStyle(self, ls)


    def addStyle(self, ls):
        """
        addStyle(LocalRenderInformation self, LocalStyle ls) -> int


        Adds a copy of the given LocalStyle to this LocalRenderInformation.

        Parameter 'ls' is the LocalStyle object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_PKG_VERSION_MISMATCH

        * LIBSBML_DUPLICATE_OBJECT_ID

        Note: This method should be used with some caution.  The fact that
        this method copies the object passed to it means that the caller will
        be left holding a physically different object instance than the one
        contained inside this object.  Changes made to the original object
        instance (such as resetting attribute values) will not affect the
        instance in this object.  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 other methods on this class
        (particularly a corresponding method whose name begins with the word
        create) for alternatives that do not lead to these issues.

        See also createLocalStyle(), getStyle(), getStyle(), getNumStyles(),
        removeStyle(), removeStyle().

        """
        return _libsbml.LocalRenderInformation_addStyle(self, ls)


    def getNumLocalStyles(self):
        """
        getNumLocalStyles(LocalRenderInformation self) -> unsigned int


        Get the number of LocalStyle objects in this LocalRenderInformation.

        Returns the number of LocalStyle objects in this
        LocalRenderInformation.

        See also addLocalStyle(), createLocalStyle(), getLocalStyle(),
        getLocalStyle(), removeLocalStyle(), removeLocalStyle().

        """
        return _libsbml.LocalRenderInformation_getNumLocalStyles(self)


    def getNumStyles(self):
        """
        getNumStyles(LocalRenderInformation self) -> unsigned int


        Get the number of LocalStyle objects in this LocalRenderInformation.

        Returns the number of LocalStyle objects in this
        LocalRenderInformation.

        See also addStyle(), createLocalStyle(), getStyle(), getStyle(),
        removeStyle(), removeStyle().

        """
        return _libsbml.LocalRenderInformation_getNumStyles(self)


    def createLocalStyle(self):
        """
        createLocalStyle(LocalRenderInformation self) -> LocalStyle


        Creates a new LocalStyle object, adds it to this
        LocalRenderInformation object and returns the LocalStyle object
        created.

        Returns a new LocalStyle object instance.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addLocalStyle(), getLocalStyle(), getLocalStyle(),
        getNumLocalStyles(), removeLocalStyle(), removeLocalStyle().

        """
        return _libsbml.LocalRenderInformation_createLocalStyle(self)


    def createStyle(self, id):
        """
        createStyle(LocalRenderInformation self, string id) -> LocalStyle


        Internal implementation method.

        """
        return _libsbml.LocalRenderInformation_createStyle(self, id)


    def removeLocalStyle(self, *args):
        """
        removeLocalStyle(LocalRenderInformation self, unsigned int n) -> LocalStyle
        removeLocalStyle(LocalRenderInformation self, string id) -> LocalStyle


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeLocalStyle(long n)

        Removes the nth LocalStyle from this LocalRenderInformation and
        returns a pointer to it.

        Parameter 'n' is a long integer representing the index of the
        LocalStyle to remove.

        Returns a pointer to the nth LocalStyle in this
        LocalRenderInformation.

        WARNING:

        The pointer that is returned by this function is owned by the caller,
        who is responsible for deleting it.  Any changes made to the element
        will not be reflected in any resulting SBML document unless the
        element is added to an SBML Document.  Even in this case, the
        element's deletion is still the responsibility of the caller with two
        exceptions: if it is used as the 'disownedItem' in the
        ListOf.appendAndOwn() or ListOf.insertAndOwn()  functions.  All other
        functions in libsbml add a copy of the element, and do not transfer
        ownership of the pointer.

        See also addLocalStyle(), createLocalStyle(), getLocalStyle(),
        getLocalStyle(), getNumLocalStyles(), removeLocalStyle().

        ______________________________________________________________________
        Method variant with the following signature:

            removeLocalStyle(string id)

        Removes the LocalStyle from this LocalRenderInformation based on its
        identifier and returns a pointer to it.

        Parameter 'id' is a string representing the identifier of the
        LocalStyle to remove.

        Returns the LocalStyle in this LocalRenderInformation based on the
        identifier or None if no such LocalStyle exists.

        WARNING:

        The pointer that is returned by this function is owned by the caller,
        who is responsible for deleting it.  Any changes made to the element
        will not be reflected in any resulting SBML document unless the
        element is added to an SBML Document.  Even in this case, the
        element's deletion is still the responsibility of the caller with two
        exceptions: if it is used as the 'disownedItem' in the
        ListOf.appendAndOwn() or ListOf.insertAndOwn()  functions.  All other
        functions in libsbml add a copy of the element, and do not transfer
        ownership of the pointer.

        See also addLocalStyle(), createLocalStyle(), getLocalStyle(),
        getLocalStyle(), getNumLocalStyles(), removeLocalStyle().

        """
        return _libsbml.LocalRenderInformation_removeLocalStyle(self, *args)


    def removeStyle(self, *args):
        """
        removeStyle(LocalRenderInformation self, unsigned int n) -> LocalStyle
        removeStyle(LocalRenderInformation self, string id) -> LocalStyle


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            removeStyle(long n)

        Removes the nth LocalStyle from this LocalRenderInformation and
        returns a pointer to it.

        Parameter 'n' is a long integer representing the index of the
        LocalStyle to remove.

        Returns a pointer to the nth LocalStyle in this
        LocalRenderInformation.

        WARNING:

        The pointer that is returned by this function is owned by the caller,
        who is responsible for deleting it.  Any changes made to the element
        will not be reflected in any resulting SBML document unless the
        element is added to an SBML Document.  Even in this case, the
        element's deletion is still the responsibility of the caller with two
        exceptions: if it is used as the 'disownedItem' in the
        ListOf.appendAndOwn() or ListOf.insertAndOwn()  functions.  All other
        functions in libsbml add a copy of the element, and do not transfer
        ownership of the pointer.

        See also addStyle(), createLocalStyle(), getStyle(), getStyle(),
        getNumStyles(), removeStyle().

        ______________________________________________________________________
        Method variant with the following signature:

            removeStyle(string id)

        Removes the LocalStyle from this LocalRenderInformation based on its
        identifier and returns a pointer to it.

        Parameter 'id' is a string representing the identifier of the
        LocalStyle to remove.

        Returns the LocalStyle in this LocalRenderInformation based on the
        identifier or None if no such LocalStyle exists.

        WARNING:

        The pointer that is returned by this function is owned by the caller,
        who is responsible for deleting it.  Any changes made to the element
        will not be reflected in any resulting SBML document unless the
        element is added to an SBML Document.  Even in this case, the
        element's deletion is still the responsibility of the caller with two
        exceptions: if it is used as the 'disownedItem' in the
        ListOf.appendAndOwn() or ListOf.insertAndOwn()  functions.  All other
        functions in libsbml add a copy of the element, and do not transfer
        ownership of the pointer.

        See also addStyle(), createLocalStyle(), getStyle(), getStyle(),
        getNumStyles(), removeStyle().

        """
        return _libsbml.LocalRenderInformation_removeStyle(self, *args)


    def getElementName(self):
        """
        getElementName(LocalRenderInformation self) -> string


        Returns the XML element name of this LocalRenderInformation object.

        For LocalRenderInformation, the XML element name is always
        ''renderInformation'.'

        Returns the name of this element, i.e. ''renderInformation'.'

        """
        return _libsbml.LocalRenderInformation_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(LocalRenderInformation self) -> int


        Returns the libSBML type code for this LocalRenderInformation object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object:
        SBML_RENDER_LOCALRENDERINFORMATION.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.LocalRenderInformation_getTypeCode(self)


    def connectToChild(self):
        """
        connectToChild(LocalRenderInformation self)


        Internal implementation method.

        """
        return _libsbml.LocalRenderInformation_connectToChild(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(LocalRenderInformation self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.LocalRenderInformation_enablePackageInternal(self, pkgURI, pkgPrefix, flag)


    def getElementBySId(self, id):
        """
        getElementBySId(LocalRenderInformation self, string id) -> SBase


        Returns the first child element that has the given 'id' in the model-
        wide SId namespace, or 'None' if no such object is found.

        Parameter 'id' is a string representing the id attribute of the object
        to retrieve.

        Returns a pointer to the SBase element with the given 'id'. If no such
        object is found, this method returns 'None.'

        """
        return _libsbml.LocalRenderInformation_getElementBySId(self, id)


    def getElementByMetaId(self, metaid):
        """
        getElementByMetaId(LocalRenderInformation self, string metaid) -> SBase


        Returns the first child element that has the given 'metaid', or 'None'
        if no such object is found.

        Parameter 'metaid' is a string representing the metaid attribute of
        the object to retrieve.

        Returns a pointer to the SBase element with the given 'metaid'. If no
        such object is found this method returns 'None.'

        """
        return _libsbml.LocalRenderInformation_getElementByMetaId(self, metaid)


    def parseXML(self, node):
        """
        parseXML(LocalRenderInformation self, XMLNode node)


        Parses the xml information in the given node and sets the attributes.
        This method should never be called by the user. It is only used to
        read render  information from annotations.

        Parameter 'node' is the XMLNode object reference that describes the
        LocalRenderInformation object to be instantiated.

        """
        return _libsbml.LocalRenderInformation_parseXML(self, node)


    def toXML(self):
        """
        toXML(LocalRenderInformation self) -> XMLNode


        Creates an XMLNode object from this LocalRenderInformation object.

        Returns the XMLNode with the XML representation for the
        LocalRenderInformation object.

        """
        return _libsbml.LocalRenderInformation_toXML(self)

LocalRenderInformation_swigregister = _libsbml.LocalRenderInformation_swigregister
LocalRenderInformation_swigregister(LocalRenderInformation)

class LocalStyle(Style):
    """

    [SBML 'render' package]

    Style information object used in LocalRenderInformation.

    Local styles are the style information objects used in
    LocalRenderInformation.  Local styles can be associated with layout
    objects by role and type as well as by id of layout objects from the
    layout the local style belongs to.

    Since LocalStyle is derived from Style, it inherits all of the methods
    and attributes from Style.

    See also LocalRenderInformation, Style.

    """

    __swig_setmethods__ = {}
    for _s in [Style]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LocalStyle, name, value)
    __swig_getmethods__ = {}
    for _s in [Style]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, LocalStyle, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(LocalStyle self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> LocalStyle
        __init__(LocalStyle self, unsigned int level, unsigned int version) -> LocalStyle
        __init__(LocalStyle self, unsigned int level) -> LocalStyle
        __init__(LocalStyle self) -> LocalStyle
        __init__(LocalStyle self, RenderPkgNamespaces renderns) -> LocalStyle
        __init__(LocalStyle self, XMLNode node, unsigned int l2version=4) -> LocalStyle
        __init__(LocalStyle self, XMLNode node) -> LocalStyle
        __init__(LocalStyle self, RenderPkgNamespaces renderns, string id) -> LocalStyle
        __init__(LocalStyle self, LocalStyle orig) -> LocalStyle


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            LocalStyle(long level = RenderExtension.getDefaultLevel(),
        long version = RenderExtension.getDefaultVersion(), long pkgVersion =
        RenderExtension.getDefaultPackageVersion())

        Creates a new LocalStyle using the given SBML Level, Version and
        "render" package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        LocalStyle.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this LocalStyle.

        Parameter 'pkgVersion' is a long integer, the SBML Render Version to
        assign to this LocalStyle.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            LocalStyle(RenderPkgNamespaces renderns, string id)

        Constructor which creates a LocalStyle with an empty group and empty
        id, role and type list. The group has to be filled before the object
        is valid.

        WARNING:

        This constructor is deprecated. The new libSBML API uses constructors
        that either take the SBML Level and Version, or take an SBMLNamespaces
        object.

        ______________________________________________________________________
        Method variant with the following signature:

            LocalStyle(XMLNode node, long l2version=4)

        Creates a new LocalStyle object from the given XMLNode object. The
        XMLNode object has to contain a valid XML representation of a
        LocalStyle object as defined in the render extension specification.
        This method is normally called when render information is read from a
        file and  should normally not have to be called explicitly.

        Parameter 'node' is the XMLNode object reference that describes the
        LocalStyle object to be instantiated.

        Parameter 'l2version' is an integer indicating the version of SBML
        Level 2

        ______________________________________________________________________
        Method variant with the following signature:

            LocalStyle(RenderPkgNamespaces renderns)

        Creates a new LocalStyle using the given RenderPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'renderns' is the RenderPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        ______________________________________________________________________
        Method variant with the following signature:

            LocalStyle(LocalStyle orig)

        Copy constructor for LocalStyle.

        Parameter 'orig' is the LocalStyle instance to copy.

        """
        this = _libsbml.new_LocalStyle(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(LocalStyle self) -> LocalStyle


        Creates and returns a deep copy of this LocalStyle object.

        Returns a (deep) copy of this LocalStyle object.

        """
        return _libsbml.LocalStyle_clone(self)

    __swig_destroy__ = _libsbml.delete_LocalStyle
    __del__ = lambda self: None

    def getIdList(self, *args):
        """
        getIdList(LocalStyle self) -> StringSet
        getIdList(LocalStyle self) -> StringSet


        Returns the value of the 'idList' attribute of this LocalStyle.

        Returns the value of the 'idList' attribute of this LocalStyle as a
        string.

        """
        return _libsbml.LocalStyle_getIdList(self, *args)


    def getNumIds(self):
        """
        getNumIds(LocalStyle self) -> unsigned int


        Returns the number of ids in the id set.

        Returns the number of ids in the id set

        """
        return _libsbml.LocalStyle_getNumIds(self)


    def isInIdList(self, id):
        """
        isInIdList(LocalStyle self, string id) -> bool


        Checks whether a given 'id' is in the id list.

        Parameter 'id' is the id to be searched for

        Returns 'True' or 'False' depending on whether the given 'id' is in
        the id list or not.

        """
        return _libsbml.LocalStyle_isInIdList(self, id)


    def addId(self, id):
        """
        addId(LocalStyle self, string id) -> int


        Adds another id to the set.

        Parameter 'id' is the id string to be added to the id list.

        """
        return _libsbml.LocalStyle_addId(self, id)


    def createIdString(self):
        """
        createIdString(LocalStyle self) -> string


        Returns the string of all roles

        """
        return _libsbml.LocalStyle_createIdString(self)


    def removeId(self, id):
        """
        removeId(LocalStyle self, string id) -> int


        Removes an id from the set.

        Parameter 'id' is the id to be removed from the id list.

        """
        return _libsbml.LocalStyle_removeId(self, id)


    def setIdList(self, idList):
        """
        setIdList(LocalStyle self, StringSet idList) -> int


        Sets the id list.

        Parameter 'idList' is The list of ids to be set on the local style.

        """
        return _libsbml.LocalStyle_setIdList(self, idList)


    def getElementName(self):
        """
        getElementName(LocalStyle self) -> string


        Returns the XML element name of this LocalStyle object.

        For LocalStyle, the XML element name is always ''style'.'

        Returns the name of this element, i.e. ''style'.'

        """
        return _libsbml.LocalStyle_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(LocalStyle self) -> int


        Returns the libSBML type code for this LocalStyle object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_RENDER_LOCALSTYLE.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.LocalStyle_getTypeCode(self)


    def toXML(self):
        """
        toXML(LocalStyle self) -> XMLNode


        Creates an XMLNode object from this LocalStyle object.

        Returns the XMLNode with the XML representation for the  LocalStyle
        object.

        """
        return _libsbml.LocalStyle_toXML(self)

LocalStyle_swigregister = _libsbml.LocalStyle_swigregister
LocalStyle_swigregister(LocalStyle)

class RadialGradient(GradientBase):
    """

    [SBML 'render' package]

    Representation of a radial gradient.

    The concept of a radial gradient is more or or less taken from SVG.  A
    radial gradient is defined by a center point, a radius and an optional
    focal point.  A valid gradient will have a positive radius  greater
    than 0, and the focal point should be within the circle defined by the
    center point and the radius.  Otherwise all restrictions for the
    GradientBase class apply.

    The center and the focal point of a radial gradient are defined by
    three pairs of absolute-relative value.  The radius is also defined as
    an absolute-relative value pair.  For examples of RadialGradient
    object definitions, see the SBML Render package specification and/or
    the SVG specification.

    See also GradientBase, RelAbsVector.

    """

    __swig_setmethods__ = {}
    for _s in [GradientBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RadialGradient, name, value)
    __swig_getmethods__ = {}
    for _s in [GradientBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, RadialGradient, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(RadialGradient self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> RadialGradient
        __init__(RadialGradient self, unsigned int level, unsigned int version) -> RadialGradient
        __init__(RadialGradient self, unsigned int level) -> RadialGradient
        __init__(RadialGradient self) -> RadialGradient
        __init__(RadialGradient self, RenderPkgNamespaces renderns) -> RadialGradient
        __init__(RadialGradient self, XMLNode node, unsigned int l2version) -> RadialGradient
        __init__(RadialGradient self, RenderPkgNamespaces renderns, string id) -> RadialGradient
        __init__(RadialGradient self, RadialGradient orig) -> RadialGradient


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            RadialGradient(long level =
        RenderExtension.getDefaultLevel(), long version =
        RenderExtension.getDefaultVersion(), long pkgVersion =
        RenderExtension.getDefaultPackageVersion())

        Creates a new RadialGradient using the given SBML Level, Version and
        "render" package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        RadialGradient.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this RadialGradient.

        Parameter 'pkgVersion' is a long integer, the SBML Render Version to
        assign to this RadialGradient.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            RadialGradient(XMLNode node, long l2version)

        Creates a new RadialGradient object from the given XMLNode object. The
        XMLNode object has to contain a valid XML representation of a
        RadialGradient object as defined in the render extension
        specification. This method is normally called when render information
        is read from a file and  should normally not have to be called
        explicitly.

        Parameter 'node' is the XMLNode object reference that describes the
        RadialGradient object to be instantiated.

        Parameter 'l2version' is an integer indicating the version of SBML
        Level 2

        ______________________________________________________________________
        Method variant with the following signature:

            RadialGradient(RenderPkgNamespaces renderns, string id)

        Constructor which creates a RadialGradient with no gradient stops. The
        id is set to the given value. The RadialGradient object is invalid
        until it has an id and at least two  gradient stops. The start and the
        end of the linear gradient vector are set to (0,0,0). A linear
        gradient with a vector of length zero should also be considered
        invalid.

        Parameter 'renderns' is the SBMLNamespaces object for the SBML
        'render' package Parameter 'id' is the new id for the RadialGradient.

        WARNING:

        This constructor is deprecated. The new libSBML API uses constructors
        that either take the SBML Level and Version, or take an SBMLNamespaces
        object.

        ______________________________________________________________________
        Method variant with the following signature:

            RadialGradient(RadialGradient orig)

        Copy constructor for RadialGradient.

        Parameter 'orig' is the RadialGradient instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            RadialGradient(RenderPkgNamespaces renderns)

        Creates a new RadialGradient using the given RenderPkgNamespaces
        object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'renderns' is the RenderPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_RadialGradient(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(RadialGradient self) -> RadialGradient


        Creates and returns a deep copy of this RadialGradient object.

        Returns a (deep) copy of this RadialGradient object.

        """
        return _libsbml.RadialGradient_clone(self)

    __swig_destroy__ = _libsbml.delete_RadialGradient
    __del__ = lambda self: None

    def getCx(self, *args):
        """
        getCx(RadialGradient self) -> RelAbsVector
        getCx(RadialGradient self) -> RelAbsVector


        Returns the value of the 'cx' element of this RadialGradient.

        Returns the value of the 'cx' element of this RadialGradient as a
        RelAbsVector.

        """
        return _libsbml.RadialGradient_getCx(self, *args)


    def getCenterX(self, *args):
        """
        getCenterX(RadialGradient self) -> RelAbsVector
        getCenterX(RadialGradient self) -> RelAbsVector


        Returns the x coordinate for the start point as a  reference.

        Returns RelAbsVector that represents the x value of the start point.

        """
        return _libsbml.RadialGradient_getCenterX(self, *args)


    def getCy(self, *args):
        """
        getCy(RadialGradient self) -> RelAbsVector
        getCy(RadialGradient self) -> RelAbsVector


        Returns the value of the 'cy' element of this RadialGradient.

        Returns the value of the 'cy' element of this RadialGradient as a
        RelAbsVector.

        """
        return _libsbml.RadialGradient_getCy(self, *args)


    def getCenterY(self, *args):
        """
        getCenterY(RadialGradient self) -> RelAbsVector
        getCenterY(RadialGradient self) -> RelAbsVector


        Returns the y coordinate for the start point as a  reference.

        Returns RelAbsVector that represents the y value of the start point.

        """
        return _libsbml.RadialGradient_getCenterY(self, *args)


    def getCz(self, *args):
        """
        getCz(RadialGradient self) -> RelAbsVector
        getCz(RadialGradient self) -> RelAbsVector


        Returns the value of the 'cz' element of this RadialGradient.

        Returns the value of the 'cz' element of this RadialGradient as a
        RelAbsVector.

        """
        return _libsbml.RadialGradient_getCz(self, *args)


    def getCenterZ(self, *args):
        """
        getCenterZ(RadialGradient self) -> RelAbsVector
        getCenterZ(RadialGradient self) -> RelAbsVector


        Returns the z coordinate for the start point as a  reference.

        Returns RelAbsVector that represents the z value of the start point.

        """
        return _libsbml.RadialGradient_getCenterZ(self, *args)


    def getR(self, *args):
        """
        getR(RadialGradient self) -> RelAbsVector
        getR(RadialGradient self) -> RelAbsVector


        Returns the value of the 'r' element of this RadialGradient.

        Returns the value of the 'r' element of this RadialGradient as a
        RelAbsVector.

        """
        return _libsbml.RadialGradient_getR(self, *args)


    def getRadius(self, *args):
        """
        getRadius(RadialGradient self) -> RelAbsVector
        getRadius(RadialGradient self) -> RelAbsVector


        Returns the radius as a  reference.

        Returns reference to the radius

        """
        return _libsbml.RadialGradient_getRadius(self, *args)


    def getFx(self, *args):
        """
        getFx(RadialGradient self) -> RelAbsVector
        getFx(RadialGradient self) -> RelAbsVector


        Returns the value of the 'fx' element of this RadialGradient.

        Returns the value of the 'fx' element of this RadialGradient as a
        RelAbsVector.

        """
        return _libsbml.RadialGradient_getFx(self, *args)


    def getFocalPointX(self, *args):
        """
        getFocalPointX(RadialGradient self) -> RelAbsVector
        getFocalPointX(RadialGradient self) -> RelAbsVector


        Returns the x coordinate for the start point as a  reference.

        Returns RelAbsVector that represents the x value of the start point.

        """
        return _libsbml.RadialGradient_getFocalPointX(self, *args)


    def getFy(self, *args):
        """
        getFy(RadialGradient self) -> RelAbsVector
        getFy(RadialGradient self) -> RelAbsVector


        Returns the value of the 'fy' element of this RadialGradient.

        Returns the value of the 'fy' element of this RadialGradient as a
        RelAbsVector.

        """
        return _libsbml.RadialGradient_getFy(self, *args)


    def getFocalPointY(self, *args):
        """
        getFocalPointY(RadialGradient self) -> RelAbsVector
        getFocalPointY(RadialGradient self) -> RelAbsVector


        Returns the y coordinate for the start point as a  reference.

        Returns RelAbsVector that represents the y value of the start point.

        """
        return _libsbml.RadialGradient_getFocalPointY(self, *args)


    def getFz(self, *args):
        """
        getFz(RadialGradient self) -> RelAbsVector
        getFz(RadialGradient self) -> RelAbsVector


        Returns the value of the 'fz' element of this RadialGradient.

        Returns the value of the 'fz' element of this RadialGradient as a
        RelAbsVector.

        """
        return _libsbml.RadialGradient_getFz(self, *args)


    def getFocalPointZ(self, *args):
        """
        getFocalPointZ(RadialGradient self) -> RelAbsVector
        getFocalPointZ(RadialGradient self) -> RelAbsVector


        Returns the z coordinate for the start point as a  reference.

        Returns RelAbsVector that represents the z value of the start point.

        """
        return _libsbml.RadialGradient_getFocalPointZ(self, *args)


    def isSetCx(self):
        """
        isSetCx(RadialGradient self) -> bool


        Predicate returning 'True' if this RadialGradient's 'cx' element is
        set.

        Returns 'True' if this RadialGradient's 'cx' element has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.RadialGradient_isSetCx(self)


    def isSetCy(self):
        """
        isSetCy(RadialGradient self) -> bool


        Predicate returning 'True' if this RadialGradient's 'cy' element is
        set.

        Returns 'True' if this RadialGradient's 'cy' element has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.RadialGradient_isSetCy(self)


    def isSetCz(self):
        """
        isSetCz(RadialGradient self) -> bool


        Predicate returning 'True' if this RadialGradient's 'cz' element is
        set.

        Returns 'True' if this RadialGradient's 'cz' element has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.RadialGradient_isSetCz(self)


    def isSetR(self):
        """
        isSetR(RadialGradient self) -> bool


        Predicate returning 'True' if this RadialGradient's 'r' element is
        set.

        Returns 'True' if this RadialGradient's 'r' element has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.RadialGradient_isSetR(self)


    def isSetFx(self):
        """
        isSetFx(RadialGradient self) -> bool


        Predicate returning 'True' if this RadialGradient's 'fx' element is
        set.

        Returns 'True' if this RadialGradient's 'fx' element has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.RadialGradient_isSetFx(self)


    def isSetFy(self):
        """
        isSetFy(RadialGradient self) -> bool


        Predicate returning 'True' if this RadialGradient's 'fy' element is
        set.

        Returns 'True' if this RadialGradient's 'fy' element has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.RadialGradient_isSetFy(self)


    def isSetFz(self):
        """
        isSetFz(RadialGradient self) -> bool


        Predicate returning 'True' if this RadialGradient's 'fz' element is
        set.

        Returns 'True' if this RadialGradient's 'fz' element has been set,
        otherwise 'False' is returned.

        """
        return _libsbml.RadialGradient_isSetFz(self)


    def setCx(self, cx):
        """
        setCx(RadialGradient self, RelAbsVector cx) -> int


        Sets the value of the 'cx' element of this RadialGradient.

        Parameter 'cx' is RelAbsVector value of the 'cx' element to be set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.RadialGradient_setCx(self, cx)


    def setCy(self, cy):
        """
        setCy(RadialGradient self, RelAbsVector cy) -> int


        Sets the value of the 'cy' element of this RadialGradient.

        Parameter 'cy' is RelAbsVector value of the 'cy' element to be set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.RadialGradient_setCy(self, cy)


    def setCz(self, cz):
        """
        setCz(RadialGradient self, RelAbsVector cz) -> int


        Sets the value of the 'cz' element of this RadialGradient.

        Parameter 'cz' is RelAbsVector value of the 'cz' element to be set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.RadialGradient_setCz(self, cz)


    def setR(self, r):
        """
        setR(RadialGradient self, RelAbsVector r) -> int


        Sets the value of the 'r' element of this RadialGradient.

        Parameter 'r' is RelAbsVector value of the 'r' element to be set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.RadialGradient_setR(self, r)


    def setRadius(self, r):
        """
        setRadius(RadialGradient self, RelAbsVector r) -> int


        Sets the radius of the radial gradient.

        Parameter 'r' is radius of the radial gradient vector.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.RadialGradient_setRadius(self, r)


    def setFx(self, fx):
        """
        setFx(RadialGradient self, RelAbsVector fx) -> int


        Sets the value of the 'fx' element of this RadialGradient.

        Parameter 'fx' is RelAbsVector value of the 'fx' element to be set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.RadialGradient_setFx(self, fx)


    def setFy(self, fy):
        """
        setFy(RadialGradient self, RelAbsVector fy) -> int


        Sets the value of the 'fy' element of this RadialGradient.

        Parameter 'fy' is RelAbsVector value of the 'fy' element to be set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.RadialGradient_setFy(self, fy)


    def setFz(self, fz):
        """
        setFz(RadialGradient self, RelAbsVector fz) -> int


        Sets the value of the 'fz' element of this RadialGradient.

        Parameter 'fz' is RelAbsVector value of the 'fz' element to be set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.RadialGradient_setFz(self, fz)


    def setCoordinates(self, *args):
        """
        setCoordinates(RadialGradient self, RelAbsVector x, RelAbsVector y, RelAbsVector z, RelAbsVector r, RelAbsVector fx, RelAbsVector fy, RelAbsVector fz)
        setCoordinates(RadialGradient self, RelAbsVector x, RelAbsVector y, RelAbsVector r, RelAbsVector fx, RelAbsVector fy)


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            setCoordinates(RelAbsVector x,RelAbsVector y,RelAbsVector
        r,RelAbsVector fx,RelAbsVector fy)

        Sets the 2D coordinates for the center and the focal point as well as
        the radius. The z values are automatically set to 0. Each value can be
        a combination of absolute and relative value and is represented by  a
        RelAbsVector object.

        Parameter 'x' is x value of the center point of the radial gradient
        vector Parameter 'y' is y value of the center point of the radial
        gradient vector Parameter 'r' is x value of the radius of the radial
        gradient vector Parameter 'fx' is x value of the focal point of the
        radial gradient vector Parameter 'fy' is y value of the focal point of
        the radial gradient vector

        ______________________________________________________________________
        Method variant with the following signature:

            setCoordinates(RelAbsVector x,RelAbsVector y,RelAbsVector
        z,RelAbsVector r,RelAbsVector fx,RelAbsVector fy,RelAbsVector fz)

        Sets the 3D coordinates for the center and the focal point as well as
        the radius. Each value can be a combination of absolute and relative
        value and is represented by  a RelAbsVector object.

        Parameter 'x' is x value of the center point of the radial gradient
        vector Parameter 'y' is y value of the center point of the radial
        gradient vector Parameter 'z' is z value of the center point of the
        radial gradient vector Parameter 'r' is x value of the radius of the
        radial gradient vector Parameter 'fx' is x value of the focal point of
        the radial gradient vector Parameter 'fy' is y value of the focal
        point of the radial gradient vector Parameter 'fz' is z value of the
        focal point of the radial gradient vector

        """
        return _libsbml.RadialGradient_setCoordinates(self, *args)


    def setCenter(self, *args):
        """
        setCenter(RadialGradient self, RelAbsVector x, RelAbsVector y, RelAbsVector z)
        setCenter(RadialGradient self, RelAbsVector x, RelAbsVector y)


        Sets the coordinates for the center point.

        Parameter 'x' is x value of the center point of the radial gradient
        vector Parameter 'y' is y value of the center point of the radial
        gradient vector Parameter 'z' is z value of the center point of the
        radial gradient vector The z argument can be omitted. In that case it
        is set to 0.

        """
        return _libsbml.RadialGradient_setCenter(self, *args)


    def setFocalPoint(self, *args):
        """
        setFocalPoint(RadialGradient self, RelAbsVector x, RelAbsVector y, RelAbsVector z)
        setFocalPoint(RadialGradient self, RelAbsVector x, RelAbsVector y)


        Sets the coordinates for the focal point.

        Parameter 'x' is x value of the focal point of the radial gradient
        vector Parameter 'y' is y value of the focal point of the radial
        gradient vector Parameter 'z' is z value of the focal point of the
        radial gradient vector. The z argument can be omitted. In that case it
        is set to 0.

        """
        return _libsbml.RadialGradient_setFocalPoint(self, *args)


    def unsetCx(self):
        """
        unsetCx(RadialGradient self) -> int


        Unsets the value of the 'cx' element of this RadialGradient.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.RadialGradient_unsetCx(self)


    def unsetCy(self):
        """
        unsetCy(RadialGradient self) -> int


        Unsets the value of the 'cy' element of this RadialGradient.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.RadialGradient_unsetCy(self)


    def unsetCz(self):
        """
        unsetCz(RadialGradient self) -> int


        Unsets the value of the 'cz' element of this RadialGradient.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.RadialGradient_unsetCz(self)


    def unsetR(self):
        """
        unsetR(RadialGradient self) -> int


        Unsets the value of the 'r' element of this RadialGradient.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.RadialGradient_unsetR(self)


    def unsetFx(self):
        """
        unsetFx(RadialGradient self) -> int


        Unsets the value of the 'fx' element of this RadialGradient.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.RadialGradient_unsetFx(self)


    def unsetFy(self):
        """
        unsetFy(RadialGradient self) -> int


        Unsets the value of the 'fy' element of this RadialGradient.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.RadialGradient_unsetFy(self)


    def unsetFz(self):
        """
        unsetFz(RadialGradient self) -> int


        Unsets the value of the 'fz' element of this RadialGradient.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.RadialGradient_unsetFz(self)


    def getElementName(self):
        """
        getElementName(RadialGradient self) -> string


        Returns the XML element name of this RadialGradient object.

        For RadialGradient, the XML element name is always ''radialGradient'.'

        Returns the name of this element, i.e. ''radialGradient'.'

        """
        return _libsbml.RadialGradient_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(RadialGradient self) -> int


        Returns the libSBML type code for this RadialGradient object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object:
        SBML_RENDER_RADIALGRADIENT.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.RadialGradient_getTypeCode(self)


    def toXML(self):
        """
        toXML(RadialGradient self) -> XMLNode


        Creates an XMLNode object from this RadialGradient object.

        Returns the XMLNode with the XML representation for the
        RadialGradient object.

        """
        return _libsbml.RadialGradient_toXML(self)

RadialGradient_swigregister = _libsbml.RadialGradient_swigregister
RadialGradient_swigregister(RadialGradient)

class DefaultValues(SBase):
    """

    [SBML 'render' package]

    Encoding of default values.

    The SBMl Render package originally (pre-SBML Level 3) specified
    default values and inheritance in a similar fashion to the
    specification used by SVG. However, in order to comply with the SBML
    development guidelines for Level 3 packages, the Render package
    specification introduced a new class of objects, DefaultValues, to
    encode these values within a model. The DefaultValues class objets can
    occur as a child of either the ListOfGlobalRenderInformation or a
    ListOfLocalRenderInformation.

    The values from DefaultValues objects are to be taken as default
    source for the values of any optional attribute that is not explicitly
    declared. If an attribute has not been declared, either explicitly on
    an element or using the DefaultValues class then software reading the
    XML may chose how they handle the attribute.  Please see the SBML
    Level 3 Render package specification for more information.

    Note that the DefaultValues associated with a
    ListOfLocalRenderInformation will override DefaultValues declared on
    the ListOfGlobalRenderInformation.

    """

    __swig_setmethods__ = {}
    for _s in [SBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DefaultValues, name, value)
    __swig_getmethods__ = {}
    for _s in [SBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, DefaultValues, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(DefaultValues self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> DefaultValues
        __init__(DefaultValues self, unsigned int level, unsigned int version) -> DefaultValues
        __init__(DefaultValues self, unsigned int level) -> DefaultValues
        __init__(DefaultValues self) -> DefaultValues
        __init__(DefaultValues self, RenderPkgNamespaces renderns) -> DefaultValues
        __init__(DefaultValues self, DefaultValues orig) -> DefaultValues


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            DefaultValues(long level = RenderExtension.getDefaultLevel(),
        long version = RenderExtension.getDefaultVersion(), long pkgVersion =
        RenderExtension.getDefaultPackageVersion())

        Creates a DefaultValues object using the given SBML Level, Version and
        "render" package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        DefaultValues.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this DefaultValues.

        Parameter 'pkgVersion' is a long integer, the SBML Render Version to
        assign to this DefaultValues.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            DefaultValues(DefaultValues orig)

        Copy constructor for DefaultValues.

        Parameter 'orig' is the DefaultValues instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            DefaultValues(RenderPkgNamespaces renderns)

        Creates a DefaultValues object using the given RenderPkgNamespaces
        object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'renderns' is the RenderPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_DefaultValues(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(DefaultValues self) -> DefaultValues


        Creates and returns a deep copy of this DefaultValues object.

        Returns a (deep) copy of this DefaultValues object.

        """
        return _libsbml.DefaultValues_clone(self)

    __swig_destroy__ = _libsbml.delete_DefaultValues
    __del__ = lambda self: None

    def getBackgroundColor(self):
        """
        getBackgroundColor(DefaultValues self) -> string


        Returns the value of the 'backgroundColor' attribute of this
        DefaultValues object.

        Returns the value of the 'backgroundColor' attribute of this
        DefaultValues as a string.

        """
        return _libsbml.DefaultValues_getBackgroundColor(self)


    def getSpreadMethod(self):
        """
        getSpreadMethod(DefaultValues self) -> GradientSpreadMethod_t


        Returns the value of the 'spreadMethod' attribute of this
        DefaultValues object.

        Returns the value of the 'spreadMethod' attribute of this
        DefaultValues object as a GradientBase::SPREADMETHOD.

        """
        return _libsbml.DefaultValues_getSpreadMethod(self)


    def getSpreadMethodAsString(self):
        """
        getSpreadMethodAsString(DefaultValues self) -> string


        Returns the value of the 'spreadMethod' attribute of this
        DefaultValues object.

        Returns the value of the 'spreadMethod' attribute of this
        DefaultValues object as a string.

        """
        return _libsbml.DefaultValues_getSpreadMethodAsString(self)


    def getLinearGradient_x1(self):
        """
        getLinearGradient_x1(DefaultValues self) -> RelAbsVector


        Returns the value of the 'linearGradient_x1' attribute of this
        DefaultValues object.

        Returns the value of the 'linearGradient_x1' attribute of this
        DefaultValues object as a string.

        """
        return _libsbml.DefaultValues_getLinearGradient_x1(self)


    def getLinearGradient_y1(self):
        """
        getLinearGradient_y1(DefaultValues self) -> RelAbsVector


        Returns the value of the 'linearGradient_y1' attribute of this
        DefaultValues object.

        Returns the value of the 'linearGradient_y1' attribute of this
        DefaultValues object as a string.

        """
        return _libsbml.DefaultValues_getLinearGradient_y1(self)


    def getLinearGradient_z1(self):
        """
        getLinearGradient_z1(DefaultValues self) -> RelAbsVector


        Returns the value of the 'linearGradient_z1' attribute of this
        DefaultValues object.

        Returns the value of the 'linearGradient_z1' attribute of this
        DefaultValues object as a string.

        """
        return _libsbml.DefaultValues_getLinearGradient_z1(self)


    def getLinearGradient_x2(self):
        """
        getLinearGradient_x2(DefaultValues self) -> RelAbsVector


        Returns the value of the 'linearGradient_x2' attribute of this
        DefaultValues object.

        Returns the value of the 'linearGradient_x2' attribute of this
        DefaultValues object as a string.

        """
        return _libsbml.DefaultValues_getLinearGradient_x2(self)


    def getLinearGradient_y2(self):
        """
        getLinearGradient_y2(DefaultValues self) -> RelAbsVector


        Returns the value of the 'linearGradient_y2' attribute of this
        DefaultValues object.

        Returns the value of the 'linearGradient_y2' attribute of this
        DefaultValues object as a string.

        """
        return _libsbml.DefaultValues_getLinearGradient_y2(self)


    def getLinearGradient_z2(self):
        """
        getLinearGradient_z2(DefaultValues self) -> RelAbsVector


        Returns the value of the 'linearGradient_z2' attribute of this
        DefaultValues object.

        Returns the value of the 'linearGradient_z2' attribute of this
        DefaultValues object as a string.

        """
        return _libsbml.DefaultValues_getLinearGradient_z2(self)


    def getRadialGradient_cx(self):
        """
        getRadialGradient_cx(DefaultValues self) -> RelAbsVector


        Returns the value of the 'radialGradient_cx' attribute of this
        DefaultValues object.

        Returns the value of the 'radialGradient_cx' attribute of this
        DefaultValues object as a string.

        """
        return _libsbml.DefaultValues_getRadialGradient_cx(self)


    def getRadialGradient_cy(self):
        """
        getRadialGradient_cy(DefaultValues self) -> RelAbsVector


        Returns the value of the 'radialGradient_cy' attribute of this
        DefaultValues object.

        Returns the value of the 'radialGradient_cy' attribute of this
        DefaultValues object as a string.

        """
        return _libsbml.DefaultValues_getRadialGradient_cy(self)


    def getRadialGradient_cz(self):
        """
        getRadialGradient_cz(DefaultValues self) -> RelAbsVector


        Returns the value of the 'radialGradient_cz' attribute of this
        DefaultValues object.

        Returns the value of the 'radialGradient_cz' attribute of this
        DefaultValues object as a string.

        """
        return _libsbml.DefaultValues_getRadialGradient_cz(self)


    def getRadialGradient_r(self):
        """
        getRadialGradient_r(DefaultValues self) -> RelAbsVector


        Returns the value of the 'radialGradient_r' attribute of this
        DefaultValues object.

        Returns the value of the 'radialGradient_r' attribute of this
        DefaultValues object as a string.

        """
        return _libsbml.DefaultValues_getRadialGradient_r(self)


    def getRadialGradient_fx(self):
        """
        getRadialGradient_fx(DefaultValues self) -> RelAbsVector


        Returns the value of the 'radialGradient_fx' attribute of this
        DefaultValues object.

        Returns the value of the 'radialGradient_fx' attribute of this
        DefaultValues object as a string.

        """
        return _libsbml.DefaultValues_getRadialGradient_fx(self)


    def getRadialGradient_fy(self):
        """
        getRadialGradient_fy(DefaultValues self) -> RelAbsVector


        Returns the value of the 'radialGradient_fy' attribute of this
        DefaultValues object.

        Returns the value of the 'radialGradient_fy' attribute of this
        DefaultValues object as a string.

        """
        return _libsbml.DefaultValues_getRadialGradient_fy(self)


    def getRadialGradient_fz(self):
        """
        getRadialGradient_fz(DefaultValues self) -> RelAbsVector


        Returns the value of the 'radialGradient_fz' attribute of this
        DefaultValues object.

        Returns the value of the 'radialGradient_fz' attribute of this
        DefaultValues object as a string.

        """
        return _libsbml.DefaultValues_getRadialGradient_fz(self)


    def getFill(self):
        """
        getFill(DefaultValues self) -> string


        Returns the value of the 'fill' attribute of this DefaultValues
        object.

        Returns the value of the 'fill' attribute of this DefaultValues object
        as a string.

        """
        return _libsbml.DefaultValues_getFill(self)


    def getFillRule(self):
        """
        getFillRule(DefaultValues self) -> int


        Returns the value of the 'fill-rule' attribute of this DefaultValues
        object.

        The attribute 'fill-rule' is used to define how polygons should be
        filled. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'fill-rule':

        * ''nonzero':' This value determines the 'insideness' of a point in
        the shape by drawing a ray from that point to infinity in any
        direction  and then examining the places where a segment of the shape
        crosses the ray.  Starting with a count of zero, add one each time a
        path segment crosses  the ray from left to right and subtract one each
        time a path segment crosses  the ray from right to left. After
        counting the crossings, if the result is  zero then the point is
        outside the path. Otherwise, it is inside.

        * ''evenodd':'  This value determines the 'insideness' of a point in
        the shape by drawing a ray from that point to infinity in any
        direction  and counting the number of path segments from the given
        shape that the ray crosses. If this number is odd, the point is
        inside; if even, the point is  outside.

        * ''inherit':' This value declares the 'insideness' of a point  in the
        shape by declaring that the property takes the same computed value  as
        the property for the element's parent. The inherited value, which is
        normally only used as a fallback value, can be clarified by setting
        'inherit' explicitly.  NOTE:  This value is NOT in the Level 3
        Version 1 Render specification, but was left out due to an oversight:
        the value has long been part of the codebase.  It is provided here as
        a convenience.  Elements with a fill-rule set to 'inherit' actually
        behave identicaly to elements without a fill-rule attribute at all,
        since this attribute always takes the value of a parent element if not
        defined explicitly.

        Returns the value of the 'fill-rule' attribute of this DefaultValues
        object as an int value.

        """
        return _libsbml.DefaultValues_getFillRule(self)


    def getFillRuleAsString(self):
        """
        getFillRuleAsString(DefaultValues self) -> string


        Returns the value of the 'fill-rule' attribute of this DefaultValues
        object.

        The attribute 'fill-rule' is used to define how polygons should be
        filled. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'fill-rule':

        * ''nonzero':' This value determines the 'insideness' of a point in
        the shape by drawing a ray from that point to infinity in any
        direction  and then examining the places where a segment of the shape
        crosses the ray.  Starting with a count of zero, add one each time a
        path segment crosses  the ray from left to right and subtract one each
        time a path segment crosses  the ray from right to left. After
        counting the crossings, if the result is  zero then the point is
        outside the path. Otherwise, it is inside.

        * ''evenodd':'  This value determines the 'insideness' of a point in
        the shape by drawing a ray from that point to infinity in any
        direction  and counting the number of path segments from the given
        shape that the ray crosses. If this number is odd, the point is
        inside; if even, the point is  outside.

        * ''inherit':' This value declares the 'insideness' of a point  in the
        shape by declaring that the property takes the same computed value  as
        the property for the element's parent. The inherited value, which is
        normally only used as a fallback value, can be clarified by setting
        'inherit' explicitly.  NOTE:  This value is NOT in the Level 3
        Version 1 Render specification, but was left out due to an oversight:
        the value has long been part of the codebase.  It is provided here as
        a convenience.  Elements with a fill-rule set to 'inherit' actually
        behave identicaly to elements without a fill-rule attribute at all,
        since this attribute always takes the value of a parent element if not
        defined explicitly.

        Returns the value of the 'fill-rule' attribute of this DefaultValues
        object as a string.

        """
        return _libsbml.DefaultValues_getFillRuleAsString(self)


    def getDefault_z(self):
        """
        getDefault_z(DefaultValues self) -> RelAbsVector


        Returns the value of the 'default_z' attribute of this DefaultValues
        object.

        Returns the value of the 'default_z' attribute of this DefaultValues
        object as a string.

        """
        return _libsbml.DefaultValues_getDefault_z(self)


    def getStroke(self):
        """
        getStroke(DefaultValues self) -> string


        Returns the value of the 'stroke' attribute of this DefaultValues
        object.

        Returns the value of the 'stroke' attribute of this DefaultValues
        object as a string.

        """
        return _libsbml.DefaultValues_getStroke(self)


    def getStrokeWidth(self):
        """
        getStrokeWidth(DefaultValues self) -> double


        Returns the value of the 'stroke-width' attribute of this
        DefaultValues object.

        Returns the value of the 'stroke-width' attribute of this
        DefaultValues object as a string.

        """
        return _libsbml.DefaultValues_getStrokeWidth(self)


    def getFontFamily(self):
        """
        getFontFamily(DefaultValues self) -> string


        Returns the value of the 'font-family' attribute of this DefaultValues
        object.

        Returns the value of the 'font-family' attribute of this DefaultValues
        object as a string.

        """
        return _libsbml.DefaultValues_getFontFamily(self)


    def getFontSize(self):
        """
        getFontSize(DefaultValues self) -> RelAbsVector


        Returns the value of the 'font-size' attribute of this DefaultValues
        object.

        Returns the value of the 'font-size' attribute of this DefaultValues
        object as a string.

        """
        return _libsbml.DefaultValues_getFontSize(self)


    def getFontWeight(self):
        """
        getFontWeight(DefaultValues self) -> FontWeight_t


        Returns the value of the 'font-weight' attribute of this DefaultValues
        object.

        The attribute 'font-weight' is used to specify whether  the text is
        to be 'normal' or 'bold'.  If omitted, the text may be rendered in
        either way. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'font-weight':

        * ''bold',' darker and/or thicker than normal print.

        * ''normal',' the typical print weight; lighter and/or thinner than
        'bold'.

        Returns the value of the 'font-weight' attribute of this DefaultValues
        object as a Text::FONT_WEIGHT.

        """
        return _libsbml.DefaultValues_getFontWeight(self)


    def getFontWeightAsString(self):
        """
        getFontWeightAsString(DefaultValues self) -> string


        Returns the value of the 'font-weight' attribute of this DefaultValues
        object.

        The attribute 'font-weight' is used to specify whether  the text is
        to be 'normal' or 'bold'.  If omitted, the text may be rendered in
        either way. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'font-weight':

        * ''bold',' darker and/or thicker than normal print.

        * ''normal',' the typical print weight; lighter and/or thinner than
        'bold'.

        Returns the value of the 'font-weight' attribute of this DefaultValues
        object as a string.

        """
        return _libsbml.DefaultValues_getFontWeightAsString(self)


    def getFontStyle(self):
        """
        getFontStyle(DefaultValues self) -> FontStyle_t


        Returns the value of the 'font-style' attribute of this DefaultValues
        object.

        The attribute 'font-style' is used to specify whether  the text is to
        be 'normal' or 'italic'.  If omitted, the text may be rendered in
        either way. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'font-style':

        * ''italic',' slanted print

        * ''normal',' upright print

        Returns the value of the 'font-style' attribute of this DefaultValues
        object as a Text::FONT_STYLE.

        """
        return _libsbml.DefaultValues_getFontStyle(self)


    def getFontStyleAsString(self):
        """
        getFontStyleAsString(DefaultValues self) -> string


        Returns the value of the 'font-style' attribute of this DefaultValues
        object.

        The attribute 'font-style' is used to specify whether  the text is to
        be 'normal' or 'italic'.  If omitted, the text may be rendered in
        either way. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'font-style':

        * ''italic',' slanted print

        * ''normal',' upright print

        Returns the value of the 'font-style' attribute of this DefaultValues
        object as a string.

        """
        return _libsbml.DefaultValues_getFontStyleAsString(self)


    def getTextAnchor(self):
        """
        getTextAnchor(DefaultValues self) -> HTextAnchor_t


        Returns the value of the 'text-anchor' attribute of this DefaultValues
        object.

        The attribute 'text-anchor' is used to specify the  horizontal
        alignment of the text.  If omitted, the text may be aligned in any
        way. In the SBML Level 3 Version 1 Render specification, the following
        are the allowable values for 'text-anchor':

        * ''start',' the start of the text is aligned to the  horizontal
        center  of the box.

        * ''middle',' the horizontal center of the text is aligned to the
        horizontal center of the box.

        * ''end',' the end of the text is aligned to the horizontal center of
        the box.

        Returns the value of the 'text-anchor' attribute of this DefaultValues
        object as a Text::TEXT_ANCHOR.

        """
        return _libsbml.DefaultValues_getTextAnchor(self)


    def getTextAnchorAsString(self):
        """
        getTextAnchorAsString(DefaultValues self) -> string


        Returns the value of the 'text-anchor' attribute of this DefaultValues
        object.

        The attribute 'text-anchor' is used to specify the  horizontal
        alignment of the text.  If omitted, the text may be aligned in any
        way. In the SBML Level 3 Version 1 Render specification, the following
        are the allowable values for 'text-anchor':

        * ''start',' the start of the text is aligned to the  horizontal
        center  of the box.

        * ''middle',' the horizontal center of the text is aligned to the
        horizontal center of the box.

        * ''end',' the end of the text is aligned to the horizontal center of
        the box.

        Returns the value of the 'text-anchor' attribute of this DefaultValues
        object as a string.

        """
        return _libsbml.DefaultValues_getTextAnchorAsString(self)


    def getVTextAnchor(self):
        """
        getVTextAnchor(DefaultValues self) -> VTextAnchor_t


        Returns the value of the 'vtext-anchor' attribute of this
        DefaultValues object.

        The attribute 'vtext-anchor' is used to specify the  vertical
        alignment of the text.  If omitted, the text may be aligned in any
        way. In the SBML Level 3 Version 1 Render specification, the following
        are the allowable values for 'vtext-anchor':

        * ''top',' the top of the text is aligned to the vertical center of
        the box.

        * ''middle',' the vertical center of the text is aligned with the
        vertical center of the box.

        * ''bottom',' the bottom of the text (i.e. the very bottom of any
        descending letter like 'y' or 'p') is aligned with the vertical
        center of the box.

        * ''baseline',' the baseline of the text (i.e. the bottom of any  non-
        descending letter like 'a' or e') is aligned with the vertical center
        of the box.

        Returns the value of the 'vtext-anchor' attribute of this
        DefaultValues object as a VTextAnchor_t.

        """
        return _libsbml.DefaultValues_getVTextAnchor(self)


    def getVTextAnchorAsString(self):
        """
        getVTextAnchorAsString(DefaultValues self) -> string


        Returns the value of the 'vtext-anchor' attribute of this
        DefaultValues object.

        The attribute 'vtext-anchor' is used to specify the  vertical
        alignment of the text.  If omitted, the text may be aligned in any
        way. In the SBML Level 3 Version 1 Render specification, the following
        are the allowable values for 'vtext-anchor':

        * ''top',' the top of the text is aligned to the vertical center of
        the box.

        * ''middle',' the vertical center of the text is aligned with the
        vertical center of the box.

        * ''bottom',' the bottom of the text (i.e. the very bottom of any
        descending letter like 'y' or 'p') is aligned with the vertical
        center of the box.

        * ''baseline',' the baseline of the text (i.e. the bottom of any  non-
        descending letter like 'a' or e') is aligned with the vertical center
        of the box.

        Returns the value of the 'vtext-anchor' attribute of this
        DefaultValues object as a string.

        """
        return _libsbml.DefaultValues_getVTextAnchorAsString(self)


    def getStartHead(self):
        """
        getStartHead(DefaultValues self) -> string


        Returns the value of the 'startHead' attribute of this DefaultValues
        object.

        Returns the value of the 'startHead' attribute of this DefaultValues
        object as a string.

        """
        return _libsbml.DefaultValues_getStartHead(self)


    def getEndHead(self):
        """
        getEndHead(DefaultValues self) -> string


        Returns the value of the 'endHead' attribute of this DefaultValues
        object.

        Returns the value of the 'endHead' attribute of this DefaultValues
        object as a string.

        """
        return _libsbml.DefaultValues_getEndHead(self)


    def getEnableRotationalMapping(self):
        """
        getEnableRotationalMapping(DefaultValues self) -> bool


        Returns the value of the 'enableRotationalMapping' attribute of this
        DefaultValues object.

        Returns the value of the 'enableRotationalMapping' attribute of this
        DefaultValues object as a boolean.

        """
        return _libsbml.DefaultValues_getEnableRotationalMapping(self)


    def isSetBackgroundColor(self):
        """
        isSetBackgroundColor(DefaultValues self) -> bool


        Predicate returning 'True' if this DefaultValues object's
        'backgroundColor' attribute is set.

        Returns 'True' if this DefaultValues object's 'backgroundColor'
        attribute has been set, otherwise 'False' is returned.

        """
        return _libsbml.DefaultValues_isSetBackgroundColor(self)


    def isSetSpreadMethod(self):
        """
        isSetSpreadMethod(DefaultValues self) -> bool


        Predicate returning 'True' if this DefaultValues object's
        'spreadMethod' attribute is set.

        Returns 'True' if this DefaultValues object's 'spreadMethod' attribute
        has been set, otherwise 'False' is returned.

        """
        return _libsbml.DefaultValues_isSetSpreadMethod(self)


    def isSetLinearGradient_x1(self):
        """
        isSetLinearGradient_x1(DefaultValues self) -> bool


        Predicate returning 'True' if this DefaultValues object's
        'linearGradient_x1' attribute is set.

        Returns 'True' if this DefaultValues object's 'linearGradient_x1'
        attribute has been set, otherwise 'False' is returned.

        """
        return _libsbml.DefaultValues_isSetLinearGradient_x1(self)


    def isSetLinearGradient_y1(self):
        """
        isSetLinearGradient_y1(DefaultValues self) -> bool


        Predicate returning 'True' if this DefaultValues object's
        'linearGradient_y1' attribute is set.

        Returns 'True' if this DefaultValues object's 'linearGradient_y1'
        attribute has been set, otherwise 'False' is returned.

        """
        return _libsbml.DefaultValues_isSetLinearGradient_y1(self)


    def isSetLinearGradient_z1(self):
        """
        isSetLinearGradient_z1(DefaultValues self) -> bool


        Predicate returning 'True' if this DefaultValues object's
        'linearGradient_z1' attribute is set.

        Returns 'True' if this DefaultValues object's 'linearGradient_z1'
        attribute has been set, otherwise 'False' is returned.

        """
        return _libsbml.DefaultValues_isSetLinearGradient_z1(self)


    def isSetLinearGradient_x2(self):
        """
        isSetLinearGradient_x2(DefaultValues self) -> bool


        Predicate returning 'True' if this DefaultValues object's
        'linearGradient_x2' attribute is set.

        Returns 'True' if this DefaultValues object's 'linearGradient_x2'
        attribute has been set, otherwise 'False' is returned.

        """
        return _libsbml.DefaultValues_isSetLinearGradient_x2(self)


    def isSetLinearGradient_y2(self):
        """
        isSetLinearGradient_y2(DefaultValues self) -> bool


        Predicate returning 'True' if this DefaultValues object's
        'linearGradient_y2' attribute is set.

        Returns 'True' if this DefaultValues object's 'linearGradient_y2'
        attribute has been set, otherwise 'False' is returned.

        """
        return _libsbml.DefaultValues_isSetLinearGradient_y2(self)


    def isSetLinearGradient_z2(self):
        """
        isSetLinearGradient_z2(DefaultValues self) -> bool


        Predicate returning 'True' if this DefaultValues object's
        'linearGradient_z2' attribute is set.

        Returns 'True' if this DefaultValues object's 'linearGradient_z2'
        attribute has been set, otherwise 'False' is returned.

        """
        return _libsbml.DefaultValues_isSetLinearGradient_z2(self)


    def isSetRadialGradient_cx(self):
        """
        isSetRadialGradient_cx(DefaultValues self) -> bool


        Predicate returning 'True' if this DefaultValues object's
        'radialGradient_cx' attribute is set.

        Returns 'True' if this DefaultValues object's 'radialGradient_cx'
        attribute has been set, otherwise 'False' is returned.

        """
        return _libsbml.DefaultValues_isSetRadialGradient_cx(self)


    def isSetRadialGradient_cy(self):
        """
        isSetRadialGradient_cy(DefaultValues self) -> bool


        Predicate returning 'True' if this DefaultValues object's
        'radialGradient_cy' attribute is set.

        Returns 'True' if this DefaultValues object's 'radialGradient_cy'
        attribute has been set, otherwise 'False' is returned.

        """
        return _libsbml.DefaultValues_isSetRadialGradient_cy(self)


    def isSetRadialGradient_cz(self):
        """
        isSetRadialGradient_cz(DefaultValues self) -> bool


        Predicate returning 'True' if this DefaultValues object's
        'radialGradient_cz' attribute is set.

        Returns 'True' if this DefaultValues object's 'radialGradient_cz'
        attribute has been set, otherwise 'False' is returned.

        """
        return _libsbml.DefaultValues_isSetRadialGradient_cz(self)


    def isSetRadialGradient_r(self):
        """
        isSetRadialGradient_r(DefaultValues self) -> bool


        Predicate returning 'True' if this DefaultValues object's
        'radialGradient_r' attribute is set.

        Returns 'True' if this DefaultValues object's 'radialGradient_r'
        attribute has been set, otherwise 'False' is returned.

        """
        return _libsbml.DefaultValues_isSetRadialGradient_r(self)


    def isSetRadialGradient_fx(self):
        """
        isSetRadialGradient_fx(DefaultValues self) -> bool


        Predicate returning 'True' if this DefaultValues object's
        'radialGradient_fx' attribute is set.

        Returns 'True' if this DefaultValues object's 'radialGradient_fx'
        attribute has been set, otherwise 'False' is returned.

        """
        return _libsbml.DefaultValues_isSetRadialGradient_fx(self)


    def isSetRadialGradient_fy(self):
        """
        isSetRadialGradient_fy(DefaultValues self) -> bool


        Predicate returning 'True' if this DefaultValues object's
        'radialGradient_fy' attribute is set.

        Returns 'True' if this DefaultValues object's 'radialGradient_fy'
        attribute has been set, otherwise 'False' is returned.

        """
        return _libsbml.DefaultValues_isSetRadialGradient_fy(self)


    def isSetRadialGradient_fz(self):
        """
        isSetRadialGradient_fz(DefaultValues self) -> bool


        Predicate returning 'True' if this DefaultValues object's
        'radialGradient_fz' attribute is set.

        Returns 'True' if this DefaultValues object's 'radialGradient_fz'
        attribute has been set, otherwise 'False' is returned.

        """
        return _libsbml.DefaultValues_isSetRadialGradient_fz(self)


    def isSetFill(self):
        """
        isSetFill(DefaultValues self) -> bool


        Predicate returning 'True' if this DefaultValues object's 'fill'
        attribute is set.

        Returns 'True' if this DefaultValues object's 'fill' attribute has
        been set, otherwise 'False' is returned.

        """
        return _libsbml.DefaultValues_isSetFill(self)


    def isSetFillRule(self):
        """
        isSetFillRule(DefaultValues self) -> bool


        Predicate returning 'True' if this DefaultValues object's 'fill-rule'
        attribute is set.

        The attribute 'fill-rule' is used to define how polygons should be
        filled. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'fill-rule':

        * ''nonzero':' This value determines the 'insideness' of a point in
        the shape by drawing a ray from that point to infinity in any
        direction  and then examining the places where a segment of the shape
        crosses the ray.  Starting with a count of zero, add one each time a
        path segment crosses  the ray from left to right and subtract one each
        time a path segment crosses  the ray from right to left. After
        counting the crossings, if the result is  zero then the point is
        outside the path. Otherwise, it is inside.

        * ''evenodd':'  This value determines the 'insideness' of a point in
        the shape by drawing a ray from that point to infinity in any
        direction  and counting the number of path segments from the given
        shape that the ray crosses. If this number is odd, the point is
        inside; if even, the point is  outside.

        * ''inherit':' This value declares the 'insideness' of a point  in the
        shape by declaring that the property takes the same computed value  as
        the property for the element's parent. The inherited value, which is
        normally only used as a fallback value, can be clarified by setting
        'inherit' explicitly.  NOTE:  This value is NOT in the Level 3
        Version 1 Render specification, but was left out due to an oversight:
        the value has long been part of the codebase.  It is provided here as
        a convenience.  Elements with a fill-rule set to 'inherit' actually
        behave identicaly to elements without a fill-rule attribute at all,
        since this attribute always takes the value of a parent element if not
        defined explicitly.

        Returns 'True' if this DefaultValues object's 'fill-rule' attribute
        has been set, otherwise 'False' is returned.

        """
        return _libsbml.DefaultValues_isSetFillRule(self)


    def isSetDefault_z(self):
        """
        isSetDefault_z(DefaultValues self) -> bool


        Predicate returning 'True' if this DefaultValues object's 'default_z'
        attribute is set.

        Returns 'True' if this DefaultValues object's 'default_z' attribute
        has been set, otherwise 'False' is returned.

        """
        return _libsbml.DefaultValues_isSetDefault_z(self)


    def isSetStroke(self):
        """
        isSetStroke(DefaultValues self) -> bool


        Predicate returning 'True' if this DefaultValues object's 'stroke'
        attribute is set.

        Returns 'True' if this DefaultValues object's 'stroke' attribute has
        been set, otherwise 'False' is returned.

        """
        return _libsbml.DefaultValues_isSetStroke(self)


    def isSetStrokeWidth(self):
        """
        isSetStrokeWidth(DefaultValues self) -> bool


        Predicate returning 'True' if this DefaultValues object's 'stroke-
        width' attribute is set.

        Returns 'True' if this DefaultValues object's 'stroke-width' attribute
        has been set, otherwise 'False' is returned.

        """
        return _libsbml.DefaultValues_isSetStrokeWidth(self)


    def isSetFontFamily(self):
        """
        isSetFontFamily(DefaultValues self) -> bool


        Predicate returning 'True' if this DefaultValues object's 'font-
        family' attribute is set.

        Returns 'True' if this DefaultValues object's 'font-family' attribute
        has been set, otherwise 'False' is returned.

        """
        return _libsbml.DefaultValues_isSetFontFamily(self)


    def isSetFontSize(self):
        """
        isSetFontSize(DefaultValues self) -> bool


        Predicate returning 'True' if this DefaultValues object's 'font-size'
        attribute is set.

        Returns 'True' if this DefaultValues object's 'font-size' attribute
        has been set, otherwise 'False' is returned.

        """
        return _libsbml.DefaultValues_isSetFontSize(self)


    def isSetFontWeight(self):
        """
        isSetFontWeight(DefaultValues self) -> bool


        Predicate returning 'True' if this DefaultValues object's 'font-
        weight' attribute is set.

        The attribute 'font-weight' is used to specify whether  the text is
        to be 'normal' or 'bold'.  If omitted, the text may be rendered in
        either way. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'font-weight':

        * ''bold',' darker and/or thicker than normal print.

        * ''normal',' the typical print weight; lighter and/or thinner than
        'bold'.

        Returns 'True' if this DefaultValues object's 'font-weight' attribute
        has been set, otherwise 'False' is returned.

        """
        return _libsbml.DefaultValues_isSetFontWeight(self)


    def isSetFontStyle(self):
        """
        isSetFontStyle(DefaultValues self) -> bool


        Predicate returning 'True' if this DefaultValues object's 'font-style'
        attribute is set.

        The attribute 'font-style' is used to specify whether  the text is to
        be 'normal' or 'italic'.  If omitted, the text may be rendered in
        either way. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'font-style':

        * ''italic',' slanted print

        * ''normal',' upright print

        Returns 'True' if this DefaultValues object's 'font-style' attribute
        has been set, otherwise 'False' is returned.

        """
        return _libsbml.DefaultValues_isSetFontStyle(self)


    def isSetTextAnchor(self):
        """
        isSetTextAnchor(DefaultValues self) -> bool


        Predicate returning 'True' if this DefaultValues object's 'text-
        anchor' attribute is set.

        The attribute 'text-anchor' is used to specify the  horizontal
        alignment of the text.  If omitted, the text may be aligned in any
        way. In the SBML Level 3 Version 1 Render specification, the following
        are the allowable values for 'text-anchor':

        * ''start',' the start of the text is aligned to the  horizontal
        center  of the box.

        * ''middle',' the horizontal center of the text is aligned to the
        horizontal center of the box.

        * ''end',' the end of the text is aligned to the horizontal center of
        the box.

        Returns 'True' if this DefaultValues object's 'text-anchor' attribute
        has been set, otherwise 'False' is returned.

        """
        return _libsbml.DefaultValues_isSetTextAnchor(self)


    def isSetVTextAnchor(self):
        """
        isSetVTextAnchor(DefaultValues self) -> bool


        Predicate returning 'True' if this DefaultValues object's 'vtext-
        anchor' attribute is set.

        The attribute 'vtext-anchor' is used to specify the  vertical
        alignment of the text.  If omitted, the text may be aligned in any
        way. In the SBML Level 3 Version 1 Render specification, the following
        are the allowable values for 'vtext-anchor':

        * ''top',' the top of the text is aligned to the vertical center of
        the box.

        * ''middle',' the vertical center of the text is aligned with the
        vertical center of the box.

        * ''bottom',' the bottom of the text (i.e. the very bottom of any
        descending letter like 'y' or 'p') is aligned with the vertical
        center of the box.

        * ''baseline',' the baseline of the text (i.e. the bottom of any  non-
        descending letter like 'a' or e') is aligned with the vertical center
        of the box.

        Returns 'True' if this DefaultValues object's 'vtext-anchor' attribute
        has been set, otherwise 'False' is returned.

        """
        return _libsbml.DefaultValues_isSetVTextAnchor(self)


    def isSetStartHead(self):
        """
        isSetStartHead(DefaultValues self) -> bool


        Predicate returning 'True' if this DefaultValues object's 'startHead'
        attribute is set.

        Returns 'True' if this DefaultValues object's 'startHead' attribute
        has been set, otherwise 'False' is returned.

        """
        return _libsbml.DefaultValues_isSetStartHead(self)


    def isSetEndHead(self):
        """
        isSetEndHead(DefaultValues self) -> bool


        Predicate returning 'True' if this DefaultValues object's 'endHead'
        attribute is set.

        Returns 'True' if this DefaultValues object's 'endHead' attribute has
        been set, otherwise 'False' is returned.

        """
        return _libsbml.DefaultValues_isSetEndHead(self)


    def isSetEnableRotationalMapping(self):
        """
        isSetEnableRotationalMapping(DefaultValues self) -> bool


        Predicate returning 'True' if this DefaultValues object's
        'enableRotationalMapping' attribute is set.

        Returns 'True' if this DefaultValues object's
        'enableRotationalMapping' attribute has been set, otherwise 'False' is
        returned.

        """
        return _libsbml.DefaultValues_isSetEnableRotationalMapping(self)


    def setBackgroundColor(self, backgroundColor):
        """
        setBackgroundColor(DefaultValues self, string backgroundColor) -> int


        Sets the value of the 'backgroundColor' attribute of this
        DefaultValues object.

        Parameter 'backgroundColor' is string& value of the 'backgroundColor'
        attribute to be set.

        Calling this function with 'backgroundColor' = 'None' or an empty
        string is equivalent to calling unsetBackgroundColor().

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.DefaultValues_setBackgroundColor(self, backgroundColor)


    def setSpreadMethod(self, *args):
        """
        setSpreadMethod(DefaultValues self, GradientBase::SPREADMETHOD const spreadMethod) -> int
        setSpreadMethod(DefaultValues self, GradientSpreadMethod_t const spreadMethod) -> int
        setSpreadMethod(DefaultValues self, string spreadMethod) -> int


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            setSpreadMethod( GradientSpreadMethod_t spreadMethod)

        Sets the value of the 'spreadMethod' attribute of this DefaultValues.

        Parameter 'spreadMethod' is int value of the 'spreadMethod' attribute
        to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        ______________________________________________________________________
        Method variant with the following signature:

            setSpreadMethod( GradientBase::SPREADMETHOD spreadMethod)

        Sets the value of the 'spreadMethod' attribute of this DefaultValues
        object.

        Parameter 'spreadMethod' is int value of the 'spreadMethod' attribute
        to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        ______________________________________________________________________
        Method variant with the following signature:

            setSpreadMethod(string spreadMethod)

        Sets the value of the 'spreadMethod' attribute of this DefaultValues
        object.

        Parameter 'spreadMethod' is string& of the 'spreadMethod' attribute to
        be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.DefaultValues_setSpreadMethod(self, *args)


    def setLinearGradient_x1(self, linearGradient_x1):
        """
        setLinearGradient_x1(DefaultValues self, RelAbsVector linearGradient_x1) -> int


        Sets the value of the 'linearGradient_x1' attribute of this
        DefaultValues object.

        Parameter 'linearGradient_x1' is RelAbsVector value of the
        'linearGradient_x1' attribute to be set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.DefaultValues_setLinearGradient_x1(self, linearGradient_x1)


    def setLinearGradient_y1(self, linearGradient_y1):
        """
        setLinearGradient_y1(DefaultValues self, RelAbsVector linearGradient_y1) -> int


        Sets the value of the 'linearGradient_y1' attribute of this
        DefaultValues object.

        Parameter 'linearGradient_y1' is RelAbsVector value of the
        'linearGradient_y1' attribute to be set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.DefaultValues_setLinearGradient_y1(self, linearGradient_y1)


    def setLinearGradient_z1(self, linearGradient_z1):
        """
        setLinearGradient_z1(DefaultValues self, RelAbsVector linearGradient_z1) -> int


        Sets the value of the 'linearGradient_z1' attribute of this
        DefaultValues object.

        Parameter 'linearGradient_z1' is RelAbsVector value of the
        'linearGradient_z1' attribute to be set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.DefaultValues_setLinearGradient_z1(self, linearGradient_z1)


    def setLinearGradient_x2(self, linearGradient_x2):
        """
        setLinearGradient_x2(DefaultValues self, RelAbsVector linearGradient_x2) -> int


        Sets the value of the 'linearGradient_x2' attribute of this
        DefaultValues object.

        Parameter 'linearGradient_x2' is RelAbsVector value of the
        'linearGradient_x2' attribute to be set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.DefaultValues_setLinearGradient_x2(self, linearGradient_x2)


    def setLinearGradient_y2(self, linearGradient_y2):
        """
        setLinearGradient_y2(DefaultValues self, RelAbsVector linearGradient_y2) -> int


        Sets the value of the 'linearGradient_y2' attribute of this
        DefaultValues object.

        Parameter 'linearGradient_y2' is RelAbsVector value of the
        'linearGradient_y2' attribute to be set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.DefaultValues_setLinearGradient_y2(self, linearGradient_y2)


    def setLinearGradient_z2(self, linearGradient_z2):
        """
        setLinearGradient_z2(DefaultValues self, RelAbsVector linearGradient_z2) -> int


        Sets the value of the 'linearGradient_z2' attribute of this
        DefaultValues object.

        Parameter 'linearGradient_z2' is RelAbsVector value of the
        'linearGradient_z2' attribute to be set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.DefaultValues_setLinearGradient_z2(self, linearGradient_z2)


    def setRadialGradient_cx(self, radialGradient_cx):
        """
        setRadialGradient_cx(DefaultValues self, RelAbsVector radialGradient_cx) -> int


        Sets the value of the 'radialGradient_cx' attribute of this
        DefaultValues object.

        Parameter 'radialGradient_cx' is RelAbsVector value of the
        'radialGradient_cx' attribute to be set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.DefaultValues_setRadialGradient_cx(self, radialGradient_cx)


    def setRadialGradient_cy(self, radialGradient_cy):
        """
        setRadialGradient_cy(DefaultValues self, RelAbsVector radialGradient_cy) -> int


        Sets the value of the 'radialGradient_cy' attribute of this
        DefaultValues object.

        Parameter 'radialGradient_cy' is RelAbsVector value of the
        'radialGradient_cy' attribute to be set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.DefaultValues_setRadialGradient_cy(self, radialGradient_cy)


    def setRadialGradient_cz(self, radialGradient_cz):
        """
        setRadialGradient_cz(DefaultValues self, RelAbsVector radialGradient_cz) -> int


        Sets the value of the 'radialGradient_cz' attribute of this
        DefaultValues object.

        Parameter 'radialGradient_cz' is RelAbsVector value of the
        'radialGradient_cz' attribute to be set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.DefaultValues_setRadialGradient_cz(self, radialGradient_cz)


    def setRadialGradient_r(self, radialGradient_r):
        """
        setRadialGradient_r(DefaultValues self, RelAbsVector radialGradient_r) -> int


        Sets the value of the 'radialGradient_r' attribute of this
        DefaultValues object.

        Parameter 'radialGradient_r' is RelAbsVector value of the
        'radialGradient_r' attribute to be set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.DefaultValues_setRadialGradient_r(self, radialGradient_r)


    def setRadialGradient_fx(self, radialGradient_fx):
        """
        setRadialGradient_fx(DefaultValues self, RelAbsVector radialGradient_fx) -> int


        Sets the value of the 'radialGradient_fx' attribute of this
        DefaultValues object.

        Parameter 'radialGradient_fx' is RelAbsVector value of the
        'radialGradient_fx' attribute to be set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.DefaultValues_setRadialGradient_fx(self, radialGradient_fx)


    def setRadialGradient_fy(self, radialGradient_fy):
        """
        setRadialGradient_fy(DefaultValues self, RelAbsVector radialGradient_fy) -> int


        Sets the value of the 'radialGradient_fy' attribute of this
        DefaultValues object.

        Parameter 'radialGradient_fy' is RelAbsVector value of the
        'radialGradient_fy' attribute to be set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.DefaultValues_setRadialGradient_fy(self, radialGradient_fy)


    def setRadialGradient_fz(self, radialGradient_fz):
        """
        setRadialGradient_fz(DefaultValues self, RelAbsVector radialGradient_fz) -> int


        Sets the value of the 'radialGradient_fz' attribute of this
        DefaultValues object.

        Parameter 'radialGradient_fz' is RelAbsVector value of the
        'radialGradient_fz' attribute to be set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.DefaultValues_setRadialGradient_fz(self, radialGradient_fz)


    def setFill(self, fill):
        """
        setFill(DefaultValues self, string fill) -> int


        Sets the value of the 'fill' attribute of this DefaultValues object.

        Parameter 'fill' is string& value of the 'fill' attribute to be set.

        Calling this function with 'fill' = 'None' or an empty string is
        equivalent to calling unsetFill().

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.DefaultValues_setFill(self, fill)


    def setFillRule(self, *args):
        """
        setFillRule(DefaultValues self, GraphicalPrimitive2D::FILL_RULE const fillRule) -> int
        setFillRule(DefaultValues self, FillRule_t fillRule) -> int
        setFillRule(DefaultValues self, string fillRule) -> int


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            setFillRule(string fillRule)

        Sets the value of the 'fill-rule' attribute of this DefaultValues
        object.

        The attribute 'fill-rule' is used to define how polygons should be
        filled. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'fill-rule':

        * ''nonzero':' This value determines the 'insideness' of a point in
        the shape by drawing a ray from that point to infinity in any
        direction  and then examining the places where a segment of the shape
        crosses the ray.  Starting with a count of zero, add one each time a
        path segment crosses  the ray from left to right and subtract one each
        time a path segment crosses  the ray from right to left. After
        counting the crossings, if the result is  zero then the point is
        outside the path. Otherwise, it is inside.

        * ''evenodd':'  This value determines the 'insideness' of a point in
        the shape by drawing a ray from that point to infinity in any
        direction  and counting the number of path segments from the given
        shape that the ray crosses. If this number is odd, the point is
        inside; if even, the point is  outside.

        * ''inherit':' This value declares the 'insideness' of a point  in the
        shape by declaring that the property takes the same computed value  as
        the property for the element's parent. The inherited value, which is
        normally only used as a fallback value, can be clarified by setting
        'inherit' explicitly.  NOTE:  This value is NOT in the Level 3
        Version 1 Render specification, but was left out due to an oversight:
        the value has long been part of the codebase.  It is provided here as
        a convenience.  Elements with a fill-rule set to 'inherit' actually
        behave identicaly to elements without a fill-rule attribute at all,
        since this attribute always takes the value of a parent element if not
        defined explicitly.

        Parameter 'fillRule' is string& of the 'fill-rule' attribute to be
        set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        ______________________________________________________________________
        Method variant with the following signature:

            setFillRule(FillRule_t fillRule)

        Sets the value of the 'fill-rule' attribute of this DefaultValues
        object.

        The attribute 'fill-rule' is used to define how polygons should be
        filled. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'fill-rule':

        * ''nonzero':' This value determines the 'insideness' of a point in
        the shape by drawing a ray from that point to infinity in any
        direction  and then examining the places where a segment of the shape
        crosses the ray.  Starting with a count of zero, add one each time a
        path segment crosses  the ray from left to right and subtract one each
        time a path segment crosses  the ray from right to left. After
        counting the crossings, if the result is  zero then the point is
        outside the path. Otherwise, it is inside.

        * ''evenodd':'  This value determines the 'insideness' of a point in
        the shape by drawing a ray from that point to infinity in any
        direction  and counting the number of path segments from the given
        shape that the ray crosses. If this number is odd, the point is
        inside; if even, the point is  outside.

        * ''inherit':' This value declares the 'insideness' of a point  in the
        shape by declaring that the property takes the same computed value  as
        the property for the element's parent. The inherited value, which is
        normally only used as a fallback value, can be clarified by setting
        'inherit' explicitly.  NOTE:  This value is NOT in the Level 3
        Version 1 Render specification, but was left out due to an oversight:
        the value has long been part of the codebase.  It is provided here as
        a convenience.  Elements with a fill-rule set to 'inherit' actually
        behave identicaly to elements without a fill-rule attribute at all,
        since this attribute always takes the value of a parent element if not
        defined explicitly.

        Parameter 'fillRule' is int value of the 'fill-rule' attribute to be
        set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        ______________________________________________________________________
        Method variant with the following signature:

            setFillRule( GraphicalPrimitive2D::FILL_RULE fillRule)

        Sets the value of the 'fill-rule' attribute of this DefaultValues
        object.

        Parameter 'fillRule' is int value of the 'fill-rule' attribute to be
        set.

        The attribute 'fill-rule' is used to define how polygons should be
        filled. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'fill-rule':

        * ''nonzero':' This value determines the 'insideness' of a point in
        the shape by drawing a ray from that point to infinity in any
        direction  and then examining the places where a segment of the shape
        crosses the ray.  Starting with a count of zero, add one each time a
        path segment crosses  the ray from left to right and subtract one each
        time a path segment crosses  the ray from right to left. After
        counting the crossings, if the result is  zero then the point is
        outside the path. Otherwise, it is inside.

        * ''evenodd':'  This value determines the 'insideness' of a point in
        the shape by drawing a ray from that point to infinity in any
        direction  and counting the number of path segments from the given
        shape that the ray crosses. If this number is odd, the point is
        inside; if even, the point is  outside.

        * ''inherit':' This value declares the 'insideness' of a point  in the
        shape by declaring that the property takes the same computed value  as
        the property for the element's parent. The inherited value, which is
        normally only used as a fallback value, can be clarified by setting
        'inherit' explicitly.  NOTE:  This value is NOT in the Level 3
        Version 1 Render specification, but was left out due to an oversight:
        the value has long been part of the codebase.  It is provided here as
        a convenience.  Elements with a fill-rule set to 'inherit' actually
        behave identicaly to elements without a fill-rule attribute at all,
        since this attribute always takes the value of a parent element if not
        defined explicitly.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.DefaultValues_setFillRule(self, *args)


    def setDefault_z(self, default_z):
        """
        setDefault_z(DefaultValues self, RelAbsVector default_z) -> int


        Sets the value of the 'default_z' attribute of this DefaultValues
        object.

        Parameter 'default_z' is RelAbsVector value of the 'default_z'
        attribute to be set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.DefaultValues_setDefault_z(self, default_z)


    def setStroke(self, stroke):
        """
        setStroke(DefaultValues self, string stroke) -> int


        Sets the value of the 'stroke' attribute of this DefaultValues object.

        Parameter 'stroke' is string& value of the 'stroke' attribute to be
        set.

        Calling this function with 'stroke' = 'None' or an empty string is
        equivalent to calling unsetStroke().

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.DefaultValues_setStroke(self, stroke)


    def setStrokeWidth(self, strokeWidth):
        """
        setStrokeWidth(DefaultValues self, double strokeWidth) -> int


        Sets the value of the 'stroke-width' attribute of this DefaultValues
        object.

        Parameter 'strokeWidth' is string& value of the 'stroke-width'
        attribute to be set.

        Calling this function with 'strokeWidth' = 'None' or an empty string
        is equivalent to calling unsetStrokeWidth().

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.DefaultValues_setStrokeWidth(self, strokeWidth)


    def setFontFamily(self, fontFamily):
        """
        setFontFamily(DefaultValues self, string fontFamily) -> int


        Sets the value of the 'font-family' attribute of this DefaultValues
        object.

        Parameter 'fontFamily' is string& value of the 'font-family' attribute
        to be set.

        Calling this function with 'fontFamily' = 'None' or an empty string is
        equivalent to calling unsetFontFamily().

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.DefaultValues_setFontFamily(self, fontFamily)


    def setFontSize(self, fontSize):
        """
        setFontSize(DefaultValues self, RelAbsVector fontSize) -> int


        Sets the value of the 'font-size' attribute of this DefaultValues
        object.

        Parameter 'fontSize' is RelAbsVector value of the 'font-size'
        attribute to be set.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.DefaultValues_setFontSize(self, fontSize)


    def setFontWeight(self, *args):
        """
        setFontWeight(DefaultValues self, Text::FONT_WEIGHT const fontWeight) -> int
        setFontWeight(DefaultValues self, FontWeight_t fontWeight) -> int
        setFontWeight(DefaultValues self, string fontWeight) -> int


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            setFontWeight(FontWeight_t fontWeight)

        Sets the value of the 'font-weight' attribute of this DefaultValues.

        The attribute 'font-weight' is used to specify whether  the text is
        to be 'normal' or 'bold'.  If omitted, the text may be rendered in
        either way. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'font-weight':

        * ''bold',' darker and/or thicker than normal print.

        * ''normal',' the typical print weight; lighter and/or thinner than
        'bold'.

        Parameter 'fontWeight' is the int value of the 'font-weight' attribute
        to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        ______________________________________________________________________
        Method variant with the following signature:

            setFontWeight( Text::FONT_WEIGHT fontWeight)

        Sets the value of the 'font-weight' attribute of this DefaultValues
        object.

        The attribute 'font-weight' is used to specify whether  the text is
        to be 'normal' or 'bold'.  If omitted, the text may be rendered in
        either way. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'font-weight':

        * ''bold',' darker and/or thicker than normal print.

        * ''normal',' the typical print weight; lighter and/or thinner than
        'bold'.

        Parameter 'fontWeight' is int value of the 'font-weight' attribute to
        be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        ______________________________________________________________________
        Method variant with the following signature:

            setFontWeight(string fontWeight)

        Sets the value of the 'font-weight' attribute of this DefaultValues.

        The attribute 'font-weight' is used to specify whether  the text is
        to be 'normal' or 'bold'.  If omitted, the text may be rendered in
        either way. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'font-weight':

        * ''bold',' darker and/or thicker than normal print.

        * ''normal',' the typical print weight; lighter and/or thinner than
        'bold'.

        Parameter 'fontWeight' is string& of the 'font-weight' attribute to be
        set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.DefaultValues_setFontWeight(self, *args)


    def setFontStyle(self, *args):
        """
        setFontStyle(DefaultValues self, Text::FONT_STYLE const fontStyle) -> int
        setFontStyle(DefaultValues self, FontStyle_t fontStyle) -> int
        setFontStyle(DefaultValues self, string fontStyle) -> int


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            setFontStyle( Text::FONT_STYLE fontStyle)

        Sets the value of the 'font-style' attribute of this DefaultValues
        object.

        The attribute 'font-style' is used to specify whether  the text is to
        be 'normal' or 'italic'.  If omitted, the text may be rendered in
        either way. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'font-style':

        * ''italic',' slanted print

        * ''normal',' upright print

        Parameter 'fontStyle' is int value of the 'font-style' attribute to be
        set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        ______________________________________________________________________
        Method variant with the following signature:

            setFontStyle(string fontStyle)

        Sets the value of the 'font-style' attribute of this DefaultValues.

        The attribute 'font-style' is used to specify whether  the text is to
        be 'normal' or 'italic'.  If omitted, the text may be rendered in
        either way. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'font-style':

        * ''italic',' slanted print

        * ''normal',' upright print

        Parameter 'fontStyle' is string& of the 'font-style' attribute to be
        set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        ______________________________________________________________________
        Method variant with the following signature:

            setFontStyle(FontStyle_t fontStyle)

        Sets the value of the 'font-style' attribute of this DefaultValues.

        The attribute 'font-style' is used to specify whether  the text is to
        be 'normal' or 'italic'.  If omitted, the text may be rendered in
        either way. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'font-style':

        * ''italic',' slanted print

        * ''normal',' upright print

        Parameter 'fontStyle' is the int value of the 'font-style' attribute
        to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.DefaultValues_setFontStyle(self, *args)


    def setTextAnchor(self, *args):
        """
        setTextAnchor(DefaultValues self, Text::TEXT_ANCHOR const textAnchor) -> int
        setTextAnchor(DefaultValues self, HTextAnchor_t textAnchor) -> int
        setTextAnchor(DefaultValues self, string textAnchor) -> int


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            setTextAnchor(string textAnchor)

        Sets the value of the 'text-anchor' attribute of this DefaultValues.

        The attribute 'text-anchor' is used to specify the  horizontal
        alignment of the text.  If omitted, the text may be aligned in any
        way. In the SBML Level 3 Version 1 Render specification, the following
        are the allowable values for 'text-anchor':

        * ''start',' the start of the text is aligned to the  horizontal
        center  of the box.

        * ''middle',' the horizontal center of the text is aligned to the
        horizontal center of the box.

        * ''end',' the end of the text is aligned to the horizontal center of
        the box.

        Parameter 'textAnchor' is string& of the 'text-anchor' attribute to be
        set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        ______________________________________________________________________
        Method variant with the following signature:

            setTextAnchor( Text::TEXT_ANCHOR textAnchor)

        Sets the value of the 'text-anchor' attribute of this DefaultValues
        object.

        The attribute 'text-anchor' is used to specify the  horizontal
        alignment of the text.  If omitted, the text may be aligned in any
        way. In the SBML Level 3 Version 1 Render specification, the following
        are the allowable values for 'text-anchor':

        * ''start',' the start of the text is aligned to the  horizontal
        center  of the box.

        * ''middle',' the horizontal center of the text is aligned to the
        horizontal center of the box.

        * ''end',' the end of the text is aligned to the horizontal center of
        the box.

        Parameter 'textAnchor' is int value of the 'text-anchor' attribute to
        be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        ______________________________________________________________________
        Method variant with the following signature:

            setTextAnchor(HTextAnchor_t textAnchor)

        Sets the value of the 'text-anchor' attribute of this DefaultValues.

        The attribute 'text-anchor' is used to specify the  horizontal
        alignment of the text.  If omitted, the text may be aligned in any
        way. In the SBML Level 3 Version 1 Render specification, the following
        are the allowable values for 'text-anchor':

        * ''start',' the start of the text is aligned to the  horizontal
        center  of the box.

        * ''middle',' the horizontal center of the text is aligned to the
        horizontal center of the box.

        * ''end',' the end of the text is aligned to the horizontal center of
        the box.

        Parameter 'textAnchor' is the int value of the 'text-anchor' attribute
        to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.DefaultValues_setTextAnchor(self, *args)


    def setVTextAnchor(self, *args):
        """
        setVTextAnchor(DefaultValues self, Text::TEXT_ANCHOR const vtextAnchor) -> int
        setVTextAnchor(DefaultValues self, VTextAnchor_t vtextAnchor) -> int
        setVTextAnchor(DefaultValues self, string vtextAnchor) -> int


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            setVTextAnchor(string vtextAnchor)

        Sets the value of the 'vtext-anchor' attribute of this DefaultValues.

        The attribute 'vtext-anchor' is used to specify the  vertical
        alignment of the text.  If omitted, the text may be aligned in any
        way. In the SBML Level 3 Version 1 Render specification, the following
        are the allowable values for 'vtext-anchor':

        * ''top',' the top of the text is aligned to the vertical center of
        the box.

        * ''middle',' the vertical center of the text is aligned with the
        vertical center of the box.

        * ''bottom',' the bottom of the text (i.e. the very bottom of any
        descending letter like 'y' or 'p') is aligned with the vertical
        center of the box.

        * ''baseline',' the baseline of the text (i.e. the bottom of any  non-
        descending letter like 'a' or e') is aligned with the vertical center
        of the box.

        Parameter 'vtextAnchor' is string& of the 'vtext-anchor' attribute to
        be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        ______________________________________________________________________
        Method variant with the following signature:

            setVTextAnchor(VTextAnchor_t vtextAnchor)

        Sets the value of the 'vtext-anchor' attribute of this DefaultValues.

        The attribute 'vtext-anchor' is used to specify the  vertical
        alignment of the text.  If omitted, the text may be aligned in any
        way. In the SBML Level 3 Version 1 Render specification, the following
        are the allowable values for 'vtext-anchor':

        * ''top',' the top of the text is aligned to the vertical center of
        the box.

        * ''middle',' the vertical center of the text is aligned with the
        vertical center of the box.

        * ''bottom',' the bottom of the text (i.e. the very bottom of any
        descending letter like 'y' or 'p') is aligned with the vertical
        center of the box.

        * ''baseline',' the baseline of the text (i.e. the bottom of any  non-
        descending letter like 'a' or e') is aligned with the vertical center
        of the box.

        Parameter 'vtextAnchor' is the int value of the 'vtext-anchor'
        attribute to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        ______________________________________________________________________
        Method variant with the following signature:

            setVTextAnchor( Text::TEXT_ANCHOR vtextAnchor)

        Sets the value of the 'vtext-anchor' attribute of this DefaultValues
        object.

        The attribute 'vtext-anchor' is used to specify the  vertical
        alignment of the text.  If omitted, the text may be aligned in any
        way. In the SBML Level 3 Version 1 Render specification, the following
        are the allowable values for 'vtext-anchor':

        * ''top',' the top of the text is aligned to the vertical center of
        the box.

        * ''middle',' the vertical center of the text is aligned with the
        vertical center of the box.

        * ''bottom',' the bottom of the text (i.e. the very bottom of any
        descending letter like 'y' or 'p') is aligned with the vertical
        center of the box.

        * ''baseline',' the baseline of the text (i.e. the bottom of any  non-
        descending letter like 'a' or e') is aligned with the vertical center
        of the box.

        Parameter 'vtextAnchor' is int value of the 'vtext-anchor' attribute
        to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.DefaultValues_setVTextAnchor(self, *args)


    def setStartHead(self, startHead):
        """
        setStartHead(DefaultValues self, string startHead) -> int


        Sets the value of the 'startHead' attribute of this DefaultValues
        object.

        Parameter 'startHead' is string& value of the 'startHead' attribute to
        be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.DefaultValues_setStartHead(self, startHead)


    def setEndHead(self, endHead):
        """
        setEndHead(DefaultValues self, string endHead) -> int


        Sets the value of the 'endHead' attribute of this DefaultValues
        object.

        Parameter 'endHead' is string& value of the 'endHead' attribute to be
        set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.DefaultValues_setEndHead(self, endHead)


    def setEnableRotationalMapping(self, enableRotationalMapping):
        """
        setEnableRotationalMapping(DefaultValues self, bool enableRotationalMapping) -> int


        Sets the value of the 'enableRotationalMapping' attribute of this
        DefaultValues object.

        Parameter 'enableRotationalMapping' is bool value of the
        'enableRotationalMapping' attribute to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.DefaultValues_setEnableRotationalMapping(self, enableRotationalMapping)


    def unsetBackgroundColor(self):
        """
        unsetBackgroundColor(DefaultValues self) -> int


        Unsets the value of the 'backgroundColor' attribute of this
        DefaultValues object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.DefaultValues_unsetBackgroundColor(self)


    def unsetSpreadMethod(self):
        """
        unsetSpreadMethod(DefaultValues self) -> int


        Unsets the value of the 'spreadMethod' attribute of this DefaultValues
        object.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.DefaultValues_unsetSpreadMethod(self)


    def unsetLinearGradient_x1(self):
        """
        unsetLinearGradient_x1(DefaultValues self) -> int


        Unsets the value of the 'linearGradient_x1' attribute of this
        DefaultValues object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.DefaultValues_unsetLinearGradient_x1(self)


    def unsetLinearGradient_y1(self):
        """
        unsetLinearGradient_y1(DefaultValues self) -> int


        Unsets the value of the 'linearGradient_y1' attribute of this
        DefaultValues object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.DefaultValues_unsetLinearGradient_y1(self)


    def unsetLinearGradient_z1(self):
        """
        unsetLinearGradient_z1(DefaultValues self) -> int


        Unsets the value of the 'linearGradient_z1' attribute of this
        DefaultValues object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.DefaultValues_unsetLinearGradient_z1(self)


    def unsetLinearGradient_x2(self):
        """
        unsetLinearGradient_x2(DefaultValues self) -> int


        Unsets the value of the 'linearGradient_x2' attribute of this
        DefaultValues object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.DefaultValues_unsetLinearGradient_x2(self)


    def unsetLinearGradient_y2(self):
        """
        unsetLinearGradient_y2(DefaultValues self) -> int


        Unsets the value of the 'linearGradient_y2' attribute of this
        DefaultValues object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.DefaultValues_unsetLinearGradient_y2(self)


    def unsetLinearGradient_z2(self):
        """
        unsetLinearGradient_z2(DefaultValues self) -> int


        Unsets the value of the 'linearGradient_z2' attribute of this
        DefaultValues object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.DefaultValues_unsetLinearGradient_z2(self)


    def unsetRadialGradient_cx(self):
        """
        unsetRadialGradient_cx(DefaultValues self) -> int


        Unsets the value of the 'radialGradient_cx' attribute of this
        DefaultValues object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.DefaultValues_unsetRadialGradient_cx(self)


    def unsetRadialGradient_cy(self):
        """
        unsetRadialGradient_cy(DefaultValues self) -> int


        Unsets the value of the 'radialGradient_cy' attribute of this
        DefaultValues object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.DefaultValues_unsetRadialGradient_cy(self)


    def unsetRadialGradient_cz(self):
        """
        unsetRadialGradient_cz(DefaultValues self) -> int


        Unsets the value of the 'radialGradient_cz' attribute of this
        DefaultValues object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.DefaultValues_unsetRadialGradient_cz(self)


    def unsetRadialGradient_r(self):
        """
        unsetRadialGradient_r(DefaultValues self) -> int


        Unsets the value of the 'radialGradient_r' attribute of this
        DefaultValues object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.DefaultValues_unsetRadialGradient_r(self)


    def unsetRadialGradient_fx(self):
        """
        unsetRadialGradient_fx(DefaultValues self) -> int


        Unsets the value of the 'radialGradient_fx' attribute of this
        DefaultValues object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.DefaultValues_unsetRadialGradient_fx(self)


    def unsetRadialGradient_fy(self):
        """
        unsetRadialGradient_fy(DefaultValues self) -> int


        Unsets the value of the 'radialGradient_fy' attribute of this
        DefaultValues object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.DefaultValues_unsetRadialGradient_fy(self)


    def unsetRadialGradient_fz(self):
        """
        unsetRadialGradient_fz(DefaultValues self) -> int


        Unsets the value of the 'radialGradient_fz' attribute of this
        DefaultValues object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.DefaultValues_unsetRadialGradient_fz(self)


    def unsetFill(self):
        """
        unsetFill(DefaultValues self) -> int


        Unsets the value of the 'fill' attribute of this DefaultValues object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.DefaultValues_unsetFill(self)


    def unsetFillRule(self):
        """
        unsetFillRule(DefaultValues self) -> int


        Unsets the value of the 'fill-rule' attribute of this DefaultValues
        object.

        The attribute 'fill-rule' is used to define how polygons should be
        filled. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'fill-rule':

        * ''nonzero':' This value determines the 'insideness' of a point in
        the shape by drawing a ray from that point to infinity in any
        direction  and then examining the places where a segment of the shape
        crosses the ray.  Starting with a count of zero, add one each time a
        path segment crosses  the ray from left to right and subtract one each
        time a path segment crosses  the ray from right to left. After
        counting the crossings, if the result is  zero then the point is
        outside the path. Otherwise, it is inside.

        * ''evenodd':'  This value determines the 'insideness' of a point in
        the shape by drawing a ray from that point to infinity in any
        direction  and counting the number of path segments from the given
        shape that the ray crosses. If this number is odd, the point is
        inside; if even, the point is  outside.

        * ''inherit':' This value declares the 'insideness' of a point  in the
        shape by declaring that the property takes the same computed value  as
        the property for the element's parent. The inherited value, which is
        normally only used as a fallback value, can be clarified by setting
        'inherit' explicitly.  NOTE:  This value is NOT in the Level 3
        Version 1 Render specification, but was left out due to an oversight:
        the value has long been part of the codebase.  It is provided here as
        a convenience.  Elements with a fill-rule set to 'inherit' actually
        behave identicaly to elements without a fill-rule attribute at all,
        since this attribute always takes the value of a parent element if not
        defined explicitly.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.DefaultValues_unsetFillRule(self)


    def unsetDefault_z(self):
        """
        unsetDefault_z(DefaultValues self) -> int


        Unsets the value of the 'default_z' attribute of this DefaultValues
        object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.DefaultValues_unsetDefault_z(self)


    def unsetStroke(self):
        """
        unsetStroke(DefaultValues self) -> int


        Unsets the value of the 'stroke' attribute of this DefaultValues
        object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.DefaultValues_unsetStroke(self)


    def unsetStrokeWidth(self):
        """
        unsetStrokeWidth(DefaultValues self) -> int


        Unsets the value of the 'stroke-width' attribute of this DefaultValues
        object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.DefaultValues_unsetStrokeWidth(self)


    def unsetFontFamily(self):
        """
        unsetFontFamily(DefaultValues self) -> int


        Unsets the value of the 'font-family' attribute of this DefaultValues
        object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.DefaultValues_unsetFontFamily(self)


    def unsetFontSize(self):
        """
        unsetFontSize(DefaultValues self) -> int


        Unsets the value of the 'font-size' attribute of this DefaultValues
        object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.DefaultValues_unsetFontSize(self)


    def unsetFontWeight(self):
        """
        unsetFontWeight(DefaultValues self) -> int


        Unsets the value of the 'font-weight' attribute of this DefaultValues
        object.

        The attribute 'font-weight' is used to specify whether  the text is
        to be 'normal' or 'bold'.  If omitted, the text may be rendered in
        either way. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'font-weight':

        * ''bold',' darker and/or thicker than normal print.

        * ''normal',' the typical print weight; lighter and/or thinner than
        'bold'.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.DefaultValues_unsetFontWeight(self)


    def unsetFontStyle(self):
        """
        unsetFontStyle(DefaultValues self) -> int


        Unsets the value of the 'font-style' attribute of this DefaultValues
        object.

        The attribute 'font-style' is used to specify whether  the text is to
        be 'normal' or 'italic'.  If omitted, the text may be rendered in
        either way. In the SBML Level 3 Version 1 Render specification, the
        following are the allowable values for 'font-style':

        * ''italic',' slanted print

        * ''normal',' upright print

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.DefaultValues_unsetFontStyle(self)


    def unsetTextAnchor(self):
        """
        unsetTextAnchor(DefaultValues self) -> int


        Unsets the value of the 'text-anchor' attribute of this DefaultValues
        object.

        The attribute 'text-anchor' is used to specify the  horizontal
        alignment of the text.  If omitted, the text may be aligned in any
        way. In the SBML Level 3 Version 1 Render specification, the following
        are the allowable values for 'text-anchor':

        * ''start',' the start of the text is aligned to the  horizontal
        center  of the box.

        * ''middle',' the horizontal center of the text is aligned to the
        horizontal center of the box.

        * ''end',' the end of the text is aligned to the horizontal center of
        the box.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.DefaultValues_unsetTextAnchor(self)


    def unsetVTextAnchor(self):
        """
        unsetVTextAnchor(DefaultValues self) -> int


        Unsets the value of the 'vtext-anchor' attribute of this DefaultValues
        object.

        The attribute 'vtext-anchor' is used to specify the  vertical
        alignment of the text.  If omitted, the text may be aligned in any
        way. In the SBML Level 3 Version 1 Render specification, the following
        are the allowable values for 'vtext-anchor':

        * ''top',' the top of the text is aligned to the vertical center of
        the box.

        * ''middle',' the vertical center of the text is aligned with the
        vertical center of the box.

        * ''bottom',' the bottom of the text (i.e. the very bottom of any
        descending letter like 'y' or 'p') is aligned with the vertical
        center of the box.

        * ''baseline',' the baseline of the text (i.e. the bottom of any  non-
        descending letter like 'a' or e') is aligned with the vertical center
        of the box.

        Returns integer value indicating success/failure of the function.
        This particular function only does one thing irrespective of user
        input or  object state, and thus will only return a single value:

        * LIBSBML_OPERATION_SUCCESS

        """
        return _libsbml.DefaultValues_unsetVTextAnchor(self)


    def unsetStartHead(self):
        """
        unsetStartHead(DefaultValues self) -> int


        Unsets the value of the 'startHead' attribute of this DefaultValues
        object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.DefaultValues_unsetStartHead(self)


    def unsetEndHead(self):
        """
        unsetEndHead(DefaultValues self) -> int


        Unsets the value of the 'endHead' attribute of this DefaultValues
        object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.DefaultValues_unsetEndHead(self)


    def unsetEnableRotationalMapping(self):
        """
        unsetEnableRotationalMapping(DefaultValues self) -> int


        Unsets the value of the 'enableRotationalMapping' attribute of this
        DefaultValues object.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.DefaultValues_unsetEnableRotationalMapping(self)


    def renameSIdRefs(self, oldid, newid):
        """
        renameSIdRefs(DefaultValues self, string oldid, string newid)


        Replaces all uses of a given 'SIdRef' type attribute value with
        another value.

        In SBML, object identifiers are of a data type called SId. In SBML
        Level 3, an explicit data type called SIdRef was introduced for
        attribute values that refer to SId values; in previous Levels of SBML,
        this data type did not exist and attributes were simply described to
        as 'referring to an identifier', but the effective data type was the
        same as SIdRef in Level 3.  These and other methods of libSBML refer
        to the type SIdRef for all Levels of SBML, even if the corresponding
        SBML specification did not explicitly name the data type.

        This method works by looking at all attributes and (if appropriate)
        mathematical formulas in MathML content, comparing the referenced
        identifiers to the value of 'oldid'.  If any matches are found, the
        matching values are replaced with 'newid'.  The method does not
        descend into child elements.

        Parameter 'oldid' is the old identifier. Parameter 'newid' is the new
        identifier.

        """
        return _libsbml.DefaultValues_renameSIdRefs(self, oldid, newid)


    def getElementName(self):
        """
        getElementName(DefaultValues self) -> string


        Returns the XML element name of this DefaultValues object.

        For DefaultValues object, the XML element name is always
        ''defaultValues'.'

        Returns the name of this element, i.e. ''defaultValues'.'

        """
        return _libsbml.DefaultValues_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(DefaultValues self) -> int


        Returns the libSBML type code for this DefaultValues object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_RENDER_DEFAULTS.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.DefaultValues_getTypeCode(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(DefaultValues self) -> bool


        Predicate returning 'True' if all the required attributes for this
        DefaultValues object have been set.

        Returns 'True' to indicate that all the required attributes of this
        DefaultValues object have been set, otherwise 'False' is returned.

        """
        return _libsbml.DefaultValues_hasRequiredAttributes(self)


    def enablePackageInternal(self, pkgURI, pkgPrefix, flag):
        """
        enablePackageInternal(DefaultValues self, string pkgURI, string pkgPrefix, bool flag)


        Internal implementation method.

        """
        return _libsbml.DefaultValues_enablePackageInternal(self, pkgURI, pkgPrefix, flag)

DefaultValues_swigregister = _libsbml.DefaultValues_swigregister
DefaultValues_swigregister(DefaultValues)

class ListOfColorDefinitions(ListOf):
    """

    [SBML 'render' package]

    A list of ColorDefinition objects.

    The ListOfColorDefinitions is a container for the ColorDefinition
    elements  of a RenderInformationBase object.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    See also ColorDefinition.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfColorDefinitions, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfColorDefinitions, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ListOfColorDefinitions self, XMLNode node) -> ListOfColorDefinitions
        __init__(ListOfColorDefinitions self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ListOfColorDefinitions
        __init__(ListOfColorDefinitions self, unsigned int level, unsigned int version) -> ListOfColorDefinitions
        __init__(ListOfColorDefinitions self, unsigned int level) -> ListOfColorDefinitions
        __init__(ListOfColorDefinitions self) -> ListOfColorDefinitions
        __init__(ListOfColorDefinitions self, RenderPkgNamespaces renderns) -> ListOfColorDefinitions
        __init__(ListOfColorDefinitions self, ListOfColorDefinitions orig) -> ListOfColorDefinitions


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfColorDefinitions(XMLNode node)

        Creates a new ListOfColorDefinitions object from the given XMLNode
        object. The XMLNode object has to contain a valid XML representation
        of a  ListOfColorDefinitions object as defined in the render extension
        specification. This method is normally called when render information
        is read from a file and  should normally not have to be called
        explicitly.

        Parameter 'node' is the XMLNode object reference that describes the
        ListOfColorDefinitions object to be instantiated.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfColorDefinitions(long level =
        RenderExtension.getDefaultLevel(), long version =
        RenderExtension.getDefaultVersion(), long pkgVersion =
        RenderExtension.getDefaultPackageVersion())

        Creates a new ListOfColorDefinitions using the given SBML Level,
        Version and "render" package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        ListOfColorDefinitions.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this ListOfColorDefinitions.

        Parameter 'pkgVersion' is a long integer, the SBML Render Version to
        assign to this ListOfColorDefinitions.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfColorDefinitions(RenderPkgNamespaces renderns)

        Creates a new ListOfColorDefinitions using the given
        RenderPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'renderns' is the RenderPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfColorDefinitions(ListOfColorDefinitions orig)

        Copy constructor for ListOfColorDefinitions.

        Parameter 'orig' is the ListOfColorDefinitions instance to copy.

        """
        this = _libsbml.new_ListOfColorDefinitions(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ListOfColorDefinitions self) -> ListOfColorDefinitions


        Creates and returns a deep copy of this ListOfColorDefinitions object.

        Returns a (deep) copy of this ListOfColorDefinitions object.

        """
        return _libsbml.ListOfColorDefinitions_clone(self)

    __swig_destroy__ = _libsbml.delete_ListOfColorDefinitions
    __del__ = lambda self: None

    def get(self, *args):
        """
        get(ListOfColorDefinitions self, unsigned int n) -> ColorDefinition
        get(ListOfColorDefinitions self, unsigned int n) -> ColorDefinition
        get(ListOfColorDefinitions self, string sid) -> ColorDefinition
        get(ListOfColorDefinitions self, string sid) -> ColorDefinition


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a ColorDefinition from the ListOfColorDefinitions.

        Parameter 'n' is a long integer representing the index of the
        ColorDefinition to retrieve.

        Returns the nth ColorDefinition in this ListOfColorDefinitions. If the
        index 'n' is invalid, 'None' is returned.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addColorDefinition(), createColorDefinition(), get(),
        getNumColorDefinitions(), remove(), remove().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a ColorDefinition from the ListOfColorDefinitions based on its
        identifier.

        Parameter 'sid' is a string representing the identifier of the
        ColorDefinition to retrieve.

        Returns the ColorDefinition in this ListOfColorDefinitions with the
        given 'sid' or 'None' if no such ColorDefinition exists.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addColorDefinition(), createColorDefinition(), get(),
        getNumColorDefinitions(), remove(), remove().

        """
        return _libsbml.ListOfColorDefinitions_get(self, *args)


    def remove(self, *args):
        """
        remove(ListOfColorDefinitions self, unsigned int n) -> ColorDefinition
        remove(ListOfColorDefinitions self, string sid) -> ColorDefinition


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth ColorDefinition from this ListOfColorDefinitions and
        returns a pointer to it.

        Parameter 'n' is a long integer representing the index of the
        ColorDefinition to remove.

        Returns a pointer to the nth ColorDefinition in this
        ListOfColorDefinitions.

        WARNING:

        The pointer that is returned by this function is owned by the caller,
        who is responsible for deleting it.  Any changes made to the element
        will not be reflected in any resulting SBML document unless the
        element is added to an SBML Document.  Even in this case, the
        element's deletion is still the responsibility of the caller with two
        exceptions: if it is used as the 'disownedItem' in the
        ListOf.appendAndOwn() or ListOf.insertAndOwn()  functions.  All other
        functions in libsbml add a copy of the element, and do not transfer
        ownership of the pointer.

        See also addColorDefinition(), createColorDefinition(), get(), get(),
        getNumColorDefinitions(), remove().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes the ColorDefinition from this ListOfColorDefinitions based on
        its identifier and returns a pointer to it.

        Parameter 'sid' is a string representing the identifier of the
        ColorDefinition to remove.

        Returns the ColorDefinition in this ListOfColorDefinitions based on
        the identifier or None if no such ColorDefinition exists.

        WARNING:

        The pointer that is returned by this function is owned by the caller,
        who is responsible for deleting it.  Any changes made to the element
        will not be reflected in any resulting SBML document unless the
        element is added to an SBML Document.  Even in this case, the
        element's deletion is still the responsibility of the caller with two
        exceptions: if it is used as the 'disownedItem' in the
        ListOf.appendAndOwn() or ListOf.insertAndOwn()  functions.  All other
        functions in libsbml add a copy of the element, and do not transfer
        ownership of the pointer.

        See also addColorDefinition(), createColorDefinition(), get(), get(),
        getNumColorDefinitions(), remove().

        """
        return _libsbml.ListOfColorDefinitions_remove(self, *args)


    def addColorDefinition(self, cd):
        """
        addColorDefinition(ListOfColorDefinitions self, ColorDefinition cd) -> int


        Adds a copy of the given ColorDefinition to this
        ListOfColorDefinitions.

        Parameter 'cd' is the ColorDefinition object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_PKG_VERSION_MISMATCH

        * LIBSBML_DUPLICATE_OBJECT_ID

        Note: This method should be used with some caution.  The fact that
        this method copies the object passed to it means that the caller will
        be left holding a physically different object instance than the one
        contained inside this object.  Changes made to the original object
        instance (such as resetting attribute values) will not affect the
        instance in this object.  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 other methods on this class
        (particularly a corresponding method whose name begins with the word
        create) for alternatives that do not lead to these issues.

        See also createColorDefinition(), get(), get(),
        getNumColorDefinitions(), remove(), remove().

        """
        return _libsbml.ListOfColorDefinitions_addColorDefinition(self, cd)


    def getNumColorDefinitions(self):
        """
        getNumColorDefinitions(ListOfColorDefinitions self) -> unsigned int


        Get the number of ColorDefinition objects in this
        ListOfColorDefinitions.

        Returns the number of ColorDefinition objects in this
        ListOfColorDefinitions.

        See also addColorDefinition(), createColorDefinition(), get(), get(),
        remove(), remove().

        """
        return _libsbml.ListOfColorDefinitions_getNumColorDefinitions(self)


    def createColorDefinition(self):
        """
        createColorDefinition(ListOfColorDefinitions self) -> ColorDefinition


        Creates a new ColorDefinition object, adds it to this
        ListOfColorDefinitions object and returns the ColorDefinition object
        created.

        Returns a new ColorDefinition object instance.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addColorDefinition(), get(), get(), getNumColorDefinitions(),
        remove(), remove().

        """
        return _libsbml.ListOfColorDefinitions_createColorDefinition(self)


    def getElementName(self):
        """
        getElementName(ListOfColorDefinitions self) -> string


        Returns the XML element name of this ListOfColorDefinitions object.

        For ListOfColorDefinitions, the XML element name is always
        ''listOfColorDefinitions'.'

        Returns the name of this element, i.e. ''listOfColorDefinitions'.'

        """
        return _libsbml.ListOfColorDefinitions_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(ListOfColorDefinitions self) -> int


        Returns the libSBML type code for this ListOfColorDefinitions object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_LIST_OF.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        """
        return _libsbml.ListOfColorDefinitions_getTypeCode(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfColorDefinitions self) -> int


        Returns the libSBML type code for the SBML objects contained in this
        ListOfColorDefinitions object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML typecode for the objects contained in this
        ListOfColorDefinitions: SBML_RENDER_COLORDEFINITION.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfColorDefinitions_getItemTypeCode(self)


    def toXML(self):
        """
        toXML(ListOfColorDefinitions self) -> XMLNode


        Creates an XMLNode object from this ListOfColorDefinitions object.

        Returns the XMLNode with the XML representation for the
        ListOfColorDefinitions object.

        """
        return _libsbml.ListOfColorDefinitions_toXML(self)

ListOfColorDefinitions_swigregister = _libsbml.ListOfColorDefinitions_swigregister
ListOfColorDefinitions_swigregister(ListOfColorDefinitions)

class ListOfCurveElements(ListOf):
    """

    [SBML 'render' package]

    A list of curve elements.

    The ListOfCurveElements is libSBML's implementation of what is called
    ListOfElements in the SBML Render specification.  It provides an
    alternative way of specifying curves and polygons.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    See also RenderPoint, RenderCubicBezier.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfCurveElements, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfCurveElements, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ListOfCurveElements self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ListOfCurveElements
        __init__(ListOfCurveElements self, unsigned int level, unsigned int version) -> ListOfCurveElements
        __init__(ListOfCurveElements self, unsigned int level) -> ListOfCurveElements
        __init__(ListOfCurveElements self) -> ListOfCurveElements
        __init__(ListOfCurveElements self, RenderPkgNamespaces renderns) -> ListOfCurveElements
        __init__(ListOfCurveElements self, XMLNode node, unsigned int l2version=4) -> ListOfCurveElements
        __init__(ListOfCurveElements self, XMLNode node) -> ListOfCurveElements
        __init__(ListOfCurveElements self, ListOfCurveElements orig) -> ListOfCurveElements


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfCurveElements(long level =
        RenderExtension.getDefaultLevel(), long version =
        RenderExtension.getDefaultVersion(), long pkgVersion =
        RenderExtension.getDefaultPackageVersion())

        Creates a new ListOfCurveElements using the given SBML Level, Version
        and "render" package version.

        The ListOfCurveElements is libSBML's implementation of what is called
        ListOfElements in the SBML Render specification.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        ListOfCurveElements.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this ListOfCurveElements.

        Parameter 'pkgVersion' is a long integer, the SBML Render Version to
        assign to this ListOfCurveElements.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfCurveElements(XMLNode node, long l2version=4)

        Creates a new ListOfCurveElements object from the given XMLNode
        object.

        This method is normally called when Render information is read from a
        file and should normally not have to be called explicitly.  The
        XMLNode object 'node' must contain a valid XML representation of a
        ListOfElements object as defined in the Render package specification.

        Parameter 'node' is the XMLNode object reference that describes the
        ListOfCurveElements object to be instantiated.

        Parameter 'l2version' is The version of SBML Level 2.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfCurveElements(RenderPkgNamespaces renderns)

        Creates a new ListOfCurveElements using the given RenderPkgNamespaces
        object.

        The ListOfCurveElements is libSBML's implementation of what is called
        ListOfElements in the SBML Render specification.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'renderns' is the RenderPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfCurveElements(ListOfCurveElements orig)

        Copy constructor for ListOfCurveElements.

        Parameter 'orig' is the ListOfCurveElements instance to copy.

        """
        this = _libsbml.new_ListOfCurveElements(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ListOfCurveElements self) -> ListOfCurveElements


        Creates and returns a deep copy of this ListOfCurveElements object.

        Returns a (deep) copy of this ListOfCurveElements object.

        """
        return _libsbml.ListOfCurveElements_clone(self)

    __swig_destroy__ = _libsbml.delete_ListOfCurveElements
    __del__ = lambda self: None

    def get(self, *args):
        """
        get(ListOfCurveElements self, unsigned int n) -> RenderPoint
        get(ListOfCurveElements self, unsigned int n) -> RenderPoint
        get(ListOfCurveElements self, string sid) -> RenderPoint
        get(ListOfCurveElements self, string sid) -> RenderPoint


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a RenderPoint from the ListOfCurveElements.

        Parameter 'n' is a long integer representing the index of the
        RenderPoint to retrieve.

        Returns the nth RenderPoint in this ListOfCurveElements. If the index
        'n' is invalid, 'None' is returned.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addRenderPoint(), createCubicBezier(), get(),
        getNumRenderPoints(), remove(), remove().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a RenderPoint from the ListOfCurveElements based on its
        identifier.

        Parameter 'sid' is a string representing the identifier of the
        RenderPoint to retrieve.

        Returns the RenderPoint in this ListOfCurveElements with the given
        'sid' or 'None' if no such RenderPoint exists.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addRenderPoint(), createCubicBezier(), get(),
        getNumRenderPoints(), remove(), remove().

        """
        return _libsbml.ListOfCurveElements_get(self, *args)


    def remove(self, *args):
        """
        remove(ListOfCurveElements self, unsigned int n) -> RenderPoint
        remove(ListOfCurveElements self, string sid) -> RenderPoint


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth RenderPoint from this ListOfCurveElements and returns
        a pointer to it.

        Parameter 'n' is a long integer representing the index of the
        RenderPoint to remove.

        Returns a pointer to the nth RenderPoint in this ListOfCurveElements.

        WARNING:

        The pointer that is returned by this function is owned by the caller,
        who is responsible for deleting it.  Any changes made to the element
        will not be reflected in any resulting SBML document unless the
        element is added to an SBML Document.  Even in this case, the
        element's deletion is still the responsibility of the caller with two
        exceptions: if it is used as the 'disownedItem' in the
        ListOf.appendAndOwn() or ListOf.insertAndOwn()  functions.  All other
        functions in libsbml add a copy of the element, and do not transfer
        ownership of the pointer.

        See also addRenderPoint(), createCubicBezier(), get(), get(),
        getNumRenderPoints(), remove().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes the RenderPoint from this ListOfCurveElements based on its
        identifier and returns a pointer to it.

        Parameter 'sid' is a string representing the identifier of the
        RenderPoint to remove.

        Returns the RenderPoint in this ListOfCurveElements based on the
        identifier or None if no such RenderPoint exists.

        WARNING:

        The pointer that is returned by this function is owned by the caller,
        who is responsible for deleting it.  Any changes made to the element
        will not be reflected in any resulting SBML document unless the
        element is added to an SBML Document.  Even in this case, the
        element's deletion is still the responsibility of the caller with two
        exceptions: if it is used as the 'disownedItem' in the
        ListOf.appendAndOwn() or ListOf.insertAndOwn()  functions.  All other
        functions in libsbml add a copy of the element, and do not transfer
        ownership of the pointer.

        See also addRenderPoint(), createCubicBezier(), get(), get(),
        getNumRenderPoints(), remove().

        """
        return _libsbml.ListOfCurveElements_remove(self, *args)


    def addRenderPoint(self, rp):
        """
        addRenderPoint(ListOfCurveElements self, RenderPoint rp) -> int


        Adds a copy of the given RenderPoint to this ListOfCurveElements.

        Parameter 'rp' is the RenderPoint object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_PKG_VERSION_MISMATCH

        * LIBSBML_DUPLICATE_OBJECT_ID

        Note: This method should be used with some caution.  The fact that
        this method copies the object passed to it means that the caller will
        be left holding a physically different object instance than the one
        contained inside this object.  Changes made to the original object
        instance (such as resetting attribute values) will not affect the
        instance in this object.  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 other methods on this class
        (particularly a corresponding method whose name begins with the word
        create) for alternatives that do not lead to these issues.

        See also createCubicBezier(), get(), get(), getNumRenderPoints(),
        remove(), remove().

        """
        return _libsbml.ListOfCurveElements_addRenderPoint(self, rp)


    def getNumRenderPoints(self):
        """
        getNumRenderPoints(ListOfCurveElements self) -> unsigned int


        Get the number of RenderPoint objects in this ListOfCurveElements.

        Returns the number of RenderPoint objects in this ListOfCurveElements.

        See also addRenderPoint(), createCubicBezier(), get(), get(),
        remove(), remove().

        """
        return _libsbml.ListOfCurveElements_getNumRenderPoints(self)


    def createCubicBezier(self):
        """
        createCubicBezier(ListOfCurveElements self) -> RenderCubicBezier


        Creates a new RenderCubicBezier object, adds it to this
        ListOfCurveElements object and returns the RenderCubicBezier object
        created.

        Returns a new RenderCubicBezier object instance.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addRenderPoint(), get(), get(), getNumRenderPoints(),
        remove(), remove().

        """
        return _libsbml.ListOfCurveElements_createCubicBezier(self)


    def getElementName(self):
        """
        getElementName(ListOfCurveElements self) -> string


        Returns the XML element name of this ListOfCurveElements object.

        For ListOfCurveElements, the XML element name is always
        ''listOfElements'.'

        Returns the name of this element, i.e. ''listOfElements'.'

        """
        return _libsbml.ListOfCurveElements_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(ListOfCurveElements self) -> int


        Returns the libSBML type code for this ListOfCurveElements object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_LIST_OF.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        """
        return _libsbml.ListOfCurveElements_getTypeCode(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfCurveElements self) -> int


        Returns the libSBML type code for the SBML objects contained in this
        ListOfCurveElements object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML typecode for the objects contained in this
        ListOfCurveElements: SBML_RENDER_POINT.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfCurveElements_getItemTypeCode(self)


    def isValidTypeForList(self, item):
        """
        isValidTypeForList(ListOfCurveElements self, SBase item) -> bool


        Internal implementation method.

        """
        return _libsbml.ListOfCurveElements_isValidTypeForList(self, item)


    def toXML(self):
        """
        toXML(ListOfCurveElements self) -> XMLNode


        Creates an XMLNode object from this ListOfCurveElements object.

        Returns the XMLNode with the XML representation for the
        ListOfCurveElements object.

        """
        return _libsbml.ListOfCurveElements_toXML(self)

ListOfCurveElements_swigregister = _libsbml.ListOfCurveElements_swigregister
ListOfCurveElements_swigregister(ListOfCurveElements)

class ListOfDrawables(ListOf):
    """

    [SBML 'render' package]

    A list of Transformation2D objects.

    The ListOfDrawables is a container for Transformation2D elements.  It
    is implemented in libSBML only, and does not appear in the 'render'
    specification, where the RenderGroup object contains child
    Transformation2D objects directly.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    See also Transformation2D, RenderGroup.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfDrawables, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfDrawables, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ListOfDrawables self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ListOfDrawables
        __init__(ListOfDrawables self, unsigned int level, unsigned int version) -> ListOfDrawables
        __init__(ListOfDrawables self, unsigned int level) -> ListOfDrawables
        __init__(ListOfDrawables self) -> ListOfDrawables
        __init__(ListOfDrawables self, RenderPkgNamespaces renderns) -> ListOfDrawables
        __init__(ListOfDrawables self, ListOfDrawables orig) -> ListOfDrawables


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfDrawables(long level =
        RenderExtension.getDefaultLevel(), long version =
        RenderExtension.getDefaultVersion(), long pkgVersion =
        RenderExtension.getDefaultPackageVersion())

        Creates a new ListOfDrawables using the given SBML Level, Version and
        "render" package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        ListOfDrawables.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this ListOfDrawables.

        Parameter 'pkgVersion' is a long integer, the SBML Render Version to
        assign to this ListOfDrawables.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfDrawables(ListOfDrawables orig)

        Copy constructor for ListOfDrawables.

        Parameter 'orig' is the ListOfDrawables instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfDrawables(RenderPkgNamespaces renderns)

        Creates a new ListOfDrawables using the given RenderPkgNamespaces
        object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'renderns' is the RenderPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_ListOfDrawables(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ListOfDrawables self) -> ListOfDrawables


        Creates and returns a deep copy of this ListOfDrawables object.

        Returns a (deep) copy of this ListOfDrawables object.

        """
        return _libsbml.ListOfDrawables_clone(self)

    __swig_destroy__ = _libsbml.delete_ListOfDrawables
    __del__ = lambda self: None

    def get(self, *args):
        """
        get(ListOfDrawables self, unsigned int n) -> Transformation2D
        get(ListOfDrawables self, unsigned int n) -> Transformation2D
        get(ListOfDrawables self, string sid) -> Transformation2D
        get(ListOfDrawables self, string sid) -> Transformation2D


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a Transformation2D from the ListOfDrawables.

        Parameter 'n' is a long integer representing the index of the
        Transformation2D to retrieve.

        Returns the nth Transformation2D in this ListOfDrawables. If the index
        'n' is invalid, 'None' is returned.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addTransformation2D(), createCurve(), createEllipse(),
        createGroup(), createImage(), createLineEnding(), createPolygon(),
        createRectangle(), createText(), get(), getNumTransformation2Ds(),
        remove(), remove().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a Transformation2D from the ListOfDrawables based on its
        identifier.

        Parameter 'sid' is a string representing the identifier of the
        Transformation2D to retrieve.

        Returns the Transformation2D in this ListOfDrawables with the given
        'sid' or 'None' if no such Transformation2D exists.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addTransformation2D(), createCurve(), createEllipse(),
        createGroup(), createImage(), createLineEnding(), createPolygon(),
        createRectangle(), createText(), get(), getNumTransformation2Ds(),
        remove(), remove().

        """
        return _libsbml.ListOfDrawables_get(self, *args)


    def remove(self, *args):
        """
        remove(ListOfDrawables self, unsigned int n) -> Transformation2D
        remove(ListOfDrawables self, string sid) -> Transformation2D


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth Transformation2D from this ListOfDrawables and returns
        a pointer to it.

        Parameter 'n' is a long integer representing the index of the
        Transformation2D to remove.

        Returns a pointer to the nth Transformation2D in this ListOfDrawables.

        WARNING:

        The pointer that is returned by this function is owned by the caller,
        who is responsible for deleting it.  Any changes made to the element
        will not be reflected in any resulting SBML document unless the
        element is added to an SBML Document.  Even in this case, the
        element's deletion is still the responsibility of the caller with two
        exceptions: if it is used as the 'disownedItem' in the
        ListOf.appendAndOwn() or ListOf.insertAndOwn()  functions.  All other
        functions in libsbml add a copy of the element, and do not transfer
        ownership of the pointer.

        See also addTransformation2D(), createCurve(), createEllipse(),
        createGroup(), createImage(), createLineEnding(), createPolygon(),
        createRectangle(), createText(), get(), get(),
        getNumTransformation2Ds(), remove().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes the Transformation2D from this ListOfDrawables based on its
        identifier and returns a pointer to it.

        Parameter 'sid' is a string representing the identifier of the
        Transformation2D to remove.

        Returns the Transformation2D in this ListOfDrawables based on the
        identifier or None if no such Transformation2D exists.

        WARNING:

        The pointer that is returned by this function is owned by the caller,
        who is responsible for deleting it.  Any changes made to the element
        will not be reflected in any resulting SBML document unless the
        element is added to an SBML Document.  Even in this case, the
        element's deletion is still the responsibility of the caller with two
        exceptions: if it is used as the 'disownedItem' in the
        ListOf.appendAndOwn() or ListOf.insertAndOwn()  functions.  All other
        functions in libsbml add a copy of the element, and do not transfer
        ownership of the pointer.

        See also addTransformation2D(), createCurve(), createEllipse(),
        createGroup(), createImage(), createLineEnding(), createPolygon(),
        createRectangle(), createText(), get(), get(),
        getNumTransformation2Ds(), remove().

        """
        return _libsbml.ListOfDrawables_remove(self, *args)


    def addTransformation2D(self, td):
        """
        addTransformation2D(ListOfDrawables self, Transformation2D td) -> int


        Adds a copy of the given Transformation2D to this ListOfDrawables.

        Parameter 'td' is the Transformation2D object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_PKG_VERSION_MISMATCH

        * LIBSBML_DUPLICATE_OBJECT_ID

        Note: This method should be used with some caution.  The fact that
        this method copies the object passed to it means that the caller will
        be left holding a physically different object instance than the one
        contained inside this object.  Changes made to the original object
        instance (such as resetting attribute values) will not affect the
        instance in this object.  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 other methods on this class
        (particularly a corresponding method whose name begins with the word
        create) for alternatives that do not lead to these issues.

        See also createCurve(), createEllipse(), createGroup(), createImage(),
        createLineEnding(), createPolygon(), createRectangle(), createText(),
        get(), get(), getNumTransformation2Ds(), remove(), remove().

        """
        return _libsbml.ListOfDrawables_addTransformation2D(self, td)


    def getNumTransformation2Ds(self):
        """
        getNumTransformation2Ds(ListOfDrawables self) -> unsigned int


        Get the number of Transformation2D objects in this ListOfDrawables.

        Returns the number of Transformation2D objects in this
        ListOfDrawables.

        See also addTransformation2D(), createCurve(), createEllipse(),
        createGroup(), createImage(), createLineEnding(), createPolygon(),
        createRectangle(), createText(), get(), get(), remove(), remove().

        """
        return _libsbml.ListOfDrawables_getNumTransformation2Ds(self)


    def createImage(self):
        """
        createImage(ListOfDrawables self) -> Image


        Creates a new Image object, adds it to this ListOfDrawables object and
        returns the Image object created.

        Returns a new Image object instance.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addTransformation2D(), createCurve(), createEllipse(),
        createGroup(), createLineEnding(), createPolygon(), createRectangle(),
        createText(), get(), get(), getNumTransformation2Ds(), remove(),
        remove().

        """
        return _libsbml.ListOfDrawables_createImage(self)


    def createEllipse(self):
        """
        createEllipse(ListOfDrawables self) -> Ellipse


        Creates a new Ellipse object, adds it to this ListOfDrawables object
        and returns the Ellipse object created.

        Returns a new Ellipse object instance.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addTransformation2D(), createCurve(), createGroup(),
        createImage(), createLineEnding(), createPolygon(), createRectangle(),
        createText(), get(), get(), getNumTransformation2Ds(), remove(),
        remove().

        """
        return _libsbml.ListOfDrawables_createEllipse(self)


    def createRectangle(self):
        """
        createRectangle(ListOfDrawables self) -> Rectangle


        Creates a new Rectangle object, adds it to this ListOfDrawables object
        and returns the Rectangle object created.

        Returns a new Rectangle object instance.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addTransformation2D(), createCurve(), createEllipse(),
        createGroup(), createImage(), createLineEnding(), createPolygon(),
        createText(), get(), get(), getNumTransformation2Ds(), remove(),
        remove().

        """
        return _libsbml.ListOfDrawables_createRectangle(self)


    def createPolygon(self):
        """
        createPolygon(ListOfDrawables self) -> Polygon


        Creates a new Polygon object, adds it to this ListOfDrawables object
        and returns the Polygon object created.

        Returns a new Polygon object instance.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addTransformation2D(), createCurve(), createEllipse(),
        createGroup(), createImage(), createLineEnding(), createRectangle(),
        createText(), get(), get(), getNumTransformation2Ds(), remove(),
        remove().

        """
        return _libsbml.ListOfDrawables_createPolygon(self)


    def createGroup(self):
        """
        createGroup(ListOfDrawables self) -> RenderGroup


        Creates a new RenderGroup object, adds it to this ListOfDrawables
        object and returns the RenderGroup object created.

        Returns a new RenderGroup object instance.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addTransformation2D(), createCurve(), createEllipse(),
        createImage(), createLineEnding(), createPolygon(), createRectangle(),
        createText(), get(), get(), getNumTransformation2Ds(), remove(),
        remove().

        """
        return _libsbml.ListOfDrawables_createGroup(self)


    def createLineEnding(self):
        """
        createLineEnding(ListOfDrawables self) -> LineEnding


        Creates a new LineEnding object, adds it to this ListOfDrawables
        object and returns the LineEnding object created.

        Returns a new LineEnding object instance.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addTransformation2D(), createCurve(), createEllipse(),
        createGroup(), createImage(), createPolygon(), createRectangle(),
        createText(), get(), get(), getNumTransformation2Ds(), remove(),
        remove().

        """
        return _libsbml.ListOfDrawables_createLineEnding(self)


    def createText(self):
        """
        createText(ListOfDrawables self) -> Text


        Creates a new Text object, adds it to this ListOfDrawables object and
        returns the Text object created.

        Returns a new Text object instance.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addTransformation2D(), createCurve(), createEllipse(),
        createGroup(), createImage(), createLineEnding(), createPolygon(),
        createRectangle(), get(), get(), getNumTransformation2Ds(), remove(),
        remove().

        """
        return _libsbml.ListOfDrawables_createText(self)


    def createCurve(self):
        """
        createCurve(ListOfDrawables self) -> RenderCurve


        Creates a new RenderCurve object, adds it to this ListOfDrawables
        object and returns the RenderCurve object created.

        Returns a new RenderCurve object instance.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addTransformation2D(), createEllipse(), createGroup(),
        createImage(), createLineEnding(), createPolygon(), createRectangle(),
        createText(), get(), get(), getNumTransformation2Ds(), remove(),
        remove().

        """
        return _libsbml.ListOfDrawables_createCurve(self)


    def getElementName(self):
        """
        getElementName(ListOfDrawables self) -> string


        Returns the XML element name of this ListOfDrawables object.

        For ListOfDrawables, the XML element name is always
        ''listOfDrawables'.'

        Returns the name of this element, i.e. ''listOfDrawables'.'

        """
        return _libsbml.ListOfDrawables_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(ListOfDrawables self) -> int


        Returns the libSBML type code for this ListOfDrawables object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_LIST_OF.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        """
        return _libsbml.ListOfDrawables_getTypeCode(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfDrawables self) -> int


        Returns the libSBML type code for the SBML objects contained in this
        ListOfDrawables object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML typecode for the objects contained in this
        ListOfDrawables: SBML_RENDER_TRANSFORMATION2D.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfDrawables_getItemTypeCode(self)

ListOfDrawables_swigregister = _libsbml.ListOfDrawables_swigregister
ListOfDrawables_swigregister(ListOfDrawables)

class ListOfGlobalRenderInformation(ListOf):
    """

    [SBML 'render' package]

    A list of GlobalRenderInformation objects.

    The ListOfGlobalRenderInformation is a container for the
    GlobalRenderInformation elements of a ListOfLayouts object.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    See also GlobalRenderInformation.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfGlobalRenderInformation, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfGlobalRenderInformation, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ListOfGlobalRenderInformation self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ListOfGlobalRenderInformation
        __init__(ListOfGlobalRenderInformation self, unsigned int level, unsigned int version) -> ListOfGlobalRenderInformation
        __init__(ListOfGlobalRenderInformation self, unsigned int level) -> ListOfGlobalRenderInformation
        __init__(ListOfGlobalRenderInformation self) -> ListOfGlobalRenderInformation
        __init__(ListOfGlobalRenderInformation self, RenderPkgNamespaces renderns) -> ListOfGlobalRenderInformation
        __init__(ListOfGlobalRenderInformation self, ListOfGlobalRenderInformation orig) -> ListOfGlobalRenderInformation


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfGlobalRenderInformation( long level =
        RenderExtension.getDefaultLevel(), long version =
        RenderExtension.getDefaultVersion(), long pkgVersion =
        RenderExtension.getDefaultPackageVersion())

        Creates a new ListOfGlobalRenderInformation using the given SBML
        Level, Version and "render" package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        ListOfGlobalRenderInformation.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this ListOfGlobalRenderInformation.

        Parameter 'pkgVersion' is a long integer, the SBML Render Version to
        assign to this ListOfGlobalRenderInformation.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfGlobalRenderInformation(RenderPkgNamespaces renderns)

        Creates a new ListOfGlobalRenderInformation using the given
        RenderPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'renderns' is the RenderPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfGlobalRenderInformation(ListOfGlobalRenderInformation
        orig)

        Copy constructor for ListOfGlobalRenderInformation.

        Parameter 'orig' is the ListOfGlobalRenderInformation instance to
        copy.

        """
        this = _libsbml.new_ListOfGlobalRenderInformation(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ListOfGlobalRenderInformation self) -> ListOfGlobalRenderInformation


        Creates and returns a deep copy of this ListOfGlobalRenderInformation
        object.

        Returns a (deep) copy of this ListOfGlobalRenderInformation object.

        """
        return _libsbml.ListOfGlobalRenderInformation_clone(self)

    __swig_destroy__ = _libsbml.delete_ListOfGlobalRenderInformation
    __del__ = lambda self: None

    def getMajorVersion(self):
        """
        getMajorVersion(ListOfGlobalRenderInformation self) -> unsigned int


        Returns the value of the 'majorVersion' attribute of this
        ListOfGlobalRenderInformation.

        Returns the value of the 'majorVersion' attribute of this
        ListOfGlobalRenderInformation as a longeger.

        """
        return _libsbml.ListOfGlobalRenderInformation_getMajorVersion(self)


    def getMinorVersion(self):
        """
        getMinorVersion(ListOfGlobalRenderInformation self) -> unsigned int


        Returns the value of the 'minorVersion' attribute of this
        ListOfGlobalRenderInformation.

        Returns the value of the 'minorVersion' attribute of this
        ListOfGlobalRenderInformation as a longeger.

        """
        return _libsbml.ListOfGlobalRenderInformation_getMinorVersion(self)


    def getVersionString(self):
        """
        getVersionString(ListOfGlobalRenderInformation self) -> string


        Returns the version as a string.

        Returns the version of the GlobalRenderInformation object as a string

        """
        return _libsbml.ListOfGlobalRenderInformation_getVersionString(self)


    def isSetMajorVersion(self):
        """
        isSetMajorVersion(ListOfGlobalRenderInformation self) -> bool


        Predicate returning 'True' if this ListOfGlobalRenderInformation's
        'majorVersion' attribute is set.

        Returns 'True' if this ListOfGlobalRenderInformation's 'majorVersion'
        attribute has been set, otherwise 'False' is returned.

        """
        return _libsbml.ListOfGlobalRenderInformation_isSetMajorVersion(self)


    def isSetMinorVersion(self):
        """
        isSetMinorVersion(ListOfGlobalRenderInformation self) -> bool


        Predicate returning 'True' if this ListOfGlobalRenderInformation's
        'minorVersion' attribute is set.

        Returns 'True' if this ListOfGlobalRenderInformation's 'minorVersion'
        attribute has been set, otherwise 'False' is returned.

        """
        return _libsbml.ListOfGlobalRenderInformation_isSetMinorVersion(self)


    def isSetVersionMajor(self):
        """
        isSetVersionMajor(ListOfGlobalRenderInformation self) -> bool


        Internal implementation method.

        """
        return _libsbml.ListOfGlobalRenderInformation_isSetVersionMajor(self)


    def isSetVersionMinor(self):
        """
        isSetVersionMinor(ListOfGlobalRenderInformation self) -> bool


        Internal implementation method.

        """
        return _libsbml.ListOfGlobalRenderInformation_isSetVersionMinor(self)


    def setMajorVersion(self, majorVersion):
        """
        setMajorVersion(ListOfGlobalRenderInformation self, unsigned int majorVersion) -> int


        Sets the value of the 'majorVersion' attribute of this
        ListOfGlobalRenderInformation.

        Parameter 'majorVersion' is long value of the 'majorVersion' attribute
        to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.ListOfGlobalRenderInformation_setMajorVersion(self, majorVersion)


    def setMinorVersion(self, minorVersion):
        """
        setMinorVersion(ListOfGlobalRenderInformation self, unsigned int minorVersion) -> int


        Sets the value of the 'minorVersion' attribute of this
        ListOfGlobalRenderInformation.

        Parameter 'minorVersion' is long value of the 'minorVersion' attribute
        to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.ListOfGlobalRenderInformation_setMinorVersion(self, minorVersion)


    def setVersionMajor(self, majorVersion):
        """
        setVersionMajor(ListOfGlobalRenderInformation self, unsigned int majorVersion) -> int


        Internal implementation method.

        """
        return _libsbml.ListOfGlobalRenderInformation_setVersionMajor(self, majorVersion)


    def setVersionMinor(self, minorVersion):
        """
        setVersionMinor(ListOfGlobalRenderInformation self, unsigned int minorVersion) -> int


        Internal implementation method.

        """
        return _libsbml.ListOfGlobalRenderInformation_setVersionMinor(self, minorVersion)


    def setVersion(self, major, minor):
        """
        setVersion(ListOfGlobalRenderInformation self, unsigned int major, unsigned int minor)


        Sets the version of the render information list. The version consists
        of a major and a minor version number.

        Parameter 'major' is major version number Parameter 'minor' is minor
        version number

        """
        return _libsbml.ListOfGlobalRenderInformation_setVersion(self, major, minor)


    def unsetMajorVersion(self):
        """
        unsetMajorVersion(ListOfGlobalRenderInformation self) -> int


        Unsets the value of the 'majorVersion' attribute of this
        ListOfGlobalRenderInformation.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.ListOfGlobalRenderInformation_unsetMajorVersion(self)


    def unsetMinorVersion(self):
        """
        unsetMinorVersion(ListOfGlobalRenderInformation self) -> int


        Unsets the value of the 'minorVersion' attribute of this
        ListOfGlobalRenderInformation.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.ListOfGlobalRenderInformation_unsetMinorVersion(self)


    def unsetVersionMajor(self):
        """
        unsetVersionMajor(ListOfGlobalRenderInformation self) -> int


        Internal implementation method.

        """
        return _libsbml.ListOfGlobalRenderInformation_unsetVersionMajor(self)


    def unsetVersionMinor(self):
        """
        unsetVersionMinor(ListOfGlobalRenderInformation self) -> int


        Internal implementation method.

        """
        return _libsbml.ListOfGlobalRenderInformation_unsetVersionMinor(self)


    def getDefaultValues(self, *args):
        """
        getDefaultValues(ListOfGlobalRenderInformation self) -> DefaultValues
        getDefaultValues(ListOfGlobalRenderInformation self) -> DefaultValues


        Returns the value of the 'defaultValues' element of this
        ListOfGlobalRenderInformation.

        Returns the value of the 'defaultValues' element of this
        ListOfGlobalRenderInformation as a DefaultValues.

        """
        return _libsbml.ListOfGlobalRenderInformation_getDefaultValues(self, *args)


    def isSetDefaultValues(self):
        """
        isSetDefaultValues(ListOfGlobalRenderInformation self) -> bool


        Predicate returning 'True' if this ListOfGlobalRenderInformation's
        'defaultValues' element is set.

        Returns 'True' if this ListOfGlobalRenderInformation's 'defaultValues'
        element has been set, otherwise 'False' is returned.

        """
        return _libsbml.ListOfGlobalRenderInformation_isSetDefaultValues(self)


    def setDefaultValues(self, defaultValues):
        """
        setDefaultValues(ListOfGlobalRenderInformation self, DefaultValues defaultValues) -> int


        Sets the value of the 'defaultValues' element of this
        ListOfGlobalRenderInformation.

        Parameter 'defaultValues' is DefaultValues value of the
        'defaultValues' element to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.ListOfGlobalRenderInformation_setDefaultValues(self, defaultValues)


    def createDefaultValues(self):
        """
        createDefaultValues(ListOfGlobalRenderInformation self) -> DefaultValues


        Creates a new DefaultValues object, adds it to this
        ListOfGlobalRenderInformation object and returns the DefaultValues
        object created.

        Returns a new DefaultValues object instance.

        """
        return _libsbml.ListOfGlobalRenderInformation_createDefaultValues(self)


    def unsetDefaultValues(self):
        """
        unsetDefaultValues(ListOfGlobalRenderInformation self) -> int


        Unsets the value of the 'defaultValues' element of this
        ListOfGlobalRenderInformation.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.ListOfGlobalRenderInformation_unsetDefaultValues(self)


    def get(self, *args):
        """
        get(ListOfGlobalRenderInformation self, unsigned int n) -> GlobalRenderInformation
        get(ListOfGlobalRenderInformation self, unsigned int n) -> GlobalRenderInformation
        get(ListOfGlobalRenderInformation self, string sid) -> GlobalRenderInformation
        get(ListOfGlobalRenderInformation self, string sid) -> GlobalRenderInformation


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a GlobalRenderInformation from the ListOfGlobalRenderInformation.

        Parameter 'n' is a long integer representing the index of the
        GlobalRenderInformation to retrieve.

        Returns the nth GlobalRenderInformation in this
        ListOfGlobalRenderInformation. If the index 'n' is invalid, 'None' is
        returned.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addGlobalRenderInformation(),
        createGlobalRenderInformation(), get(),
        getNumGlobalRenderInformation(), remove(), remove().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a GlobalRenderInformation from the ListOfGlobalRenderInformation
        based on its identifier.

        Parameter 'sid' is a string representing the identifier of the
        GlobalRenderInformation to retrieve.

        Returns the GlobalRenderInformation in this
        ListOfGlobalRenderInformation with the given 'sid' or 'None' if no
        such GlobalRenderInformation exists.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addGlobalRenderInformation(),
        createGlobalRenderInformation(), get(),
        getNumGlobalRenderInformation(), remove(), remove().

        """
        return _libsbml.ListOfGlobalRenderInformation_get(self, *args)


    def remove(self, *args):
        """
        remove(ListOfGlobalRenderInformation self, unsigned int n) -> GlobalRenderInformation
        remove(ListOfGlobalRenderInformation self, string sid) -> GlobalRenderInformation


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth GlobalRenderInformation from this
        ListOfGlobalRenderInformation and returns a pointer to it.

        Parameter 'n' is a long integer representing the index of the
        GlobalRenderInformation to remove.

        Returns a pointer to the nth GlobalRenderInformation in this
        ListOfGlobalRenderInformation.

        WARNING:

        The pointer that is returned by this function is owned by the caller,
        who is responsible for deleting it.  Any changes made to the element
        will not be reflected in any resulting SBML document unless the
        element is added to an SBML Document.  Even in this case, the
        element's deletion is still the responsibility of the caller with two
        exceptions: if it is used as the 'disownedItem' in the
        ListOf.appendAndOwn() or ListOf.insertAndOwn()  functions.  All other
        functions in libsbml add a copy of the element, and do not transfer
        ownership of the pointer.

        See also addGlobalRenderInformation(),
        createGlobalRenderInformation(), get(), get(),
        getNumGlobalRenderInformation(), remove().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes the GlobalRenderInformation from this
        ListOfGlobalRenderInformation based on its identifier and returns a
        pointer to it.

        Parameter 'sid' is a string representing the identifier of the
        GlobalRenderInformation to remove.

        Returns the GlobalRenderInformation in this
        ListOfGlobalRenderInformation based on the identifier or None if no
        such GlobalRenderInformation exists.

        WARNING:

        The pointer that is returned by this function is owned by the caller,
        who is responsible for deleting it.  Any changes made to the element
        will not be reflected in any resulting SBML document unless the
        element is added to an SBML Document.  Even in this case, the
        element's deletion is still the responsibility of the caller with two
        exceptions: if it is used as the 'disownedItem' in the
        ListOf.appendAndOwn() or ListOf.insertAndOwn()  functions.  All other
        functions in libsbml add a copy of the element, and do not transfer
        ownership of the pointer.

        See also addGlobalRenderInformation(),
        createGlobalRenderInformation(), get(), get(),
        getNumGlobalRenderInformation(), remove().

        """
        return _libsbml.ListOfGlobalRenderInformation_remove(self, *args)


    def addGlobalRenderInformation(self, gri):
        """
        addGlobalRenderInformation(ListOfGlobalRenderInformation self, GlobalRenderInformation gri) -> int


        Adds a copy of the given GlobalRenderInformation to this
        ListOfGlobalRenderInformation.

        Parameter 'gri' is the GlobalRenderInformation object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_PKG_VERSION_MISMATCH

        * LIBSBML_DUPLICATE_OBJECT_ID

        Note: This method should be used with some caution.  The fact that
        this method copies the object passed to it means that the caller will
        be left holding a physically different object instance than the one
        contained inside this object.  Changes made to the original object
        instance (such as resetting attribute values) will not affect the
        instance in this object.  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 other methods on this class
        (particularly a corresponding method whose name begins with the word
        create) for alternatives that do not lead to these issues.

        See also createGlobalRenderInformation(), get(), get(),
        getNumGlobalRenderInformation(), remove(), remove().

        """
        return _libsbml.ListOfGlobalRenderInformation_addGlobalRenderInformation(self, gri)


    def getNumGlobalRenderInformation(self):
        """
        getNumGlobalRenderInformation(ListOfGlobalRenderInformation self) -> unsigned int


        Get the number of GlobalRenderInformation objects in this
        ListOfGlobalRenderInformation.

        Returns the number of GlobalRenderInformation objects in this
        ListOfGlobalRenderInformation.

        See also addGlobalRenderInformation(),
        createGlobalRenderInformation(), get(), get(), remove(), remove().

        """
        return _libsbml.ListOfGlobalRenderInformation_getNumGlobalRenderInformation(self)


    def createGlobalRenderInformation(self):
        """
        createGlobalRenderInformation(ListOfGlobalRenderInformation self) -> GlobalRenderInformation


        Creates a new GlobalRenderInformation object, adds it to this
        ListOfGlobalRenderInformation object and returns the
        GlobalRenderInformation object created.

        Returns a new GlobalRenderInformation object instance.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addGlobalRenderInformation(), get(), get(),
        getNumGlobalRenderInformation(), remove(), remove().

        """
        return _libsbml.ListOfGlobalRenderInformation_createGlobalRenderInformation(self)


    def getElementName(self):
        """
        getElementName(ListOfGlobalRenderInformation self) -> string


        Returns the XML element name of this ListOfGlobalRenderInformation
        object.

        For ListOfGlobalRenderInformation, the XML element name is always
        ''listOfGlobalRenderInformation'.'

        Returns the name of this element, i.e.
        ''listOfGlobalRenderInformation'.'

        """
        return _libsbml.ListOfGlobalRenderInformation_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(ListOfGlobalRenderInformation self) -> int


        Returns the libSBML type code for this ListOfGlobalRenderInformation
        object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_LIST_OF.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        """
        return _libsbml.ListOfGlobalRenderInformation_getTypeCode(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfGlobalRenderInformation self) -> int


        Returns the libSBML type code for the SBML objects contained in this
        ListOfGlobalRenderInformation object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML typecode for the objects contained in this
        ListOfGlobalRenderInformation: SBML_RENDER_GLOBALRENDERINFORMATION.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfGlobalRenderInformation_getItemTypeCode(self)


    def isValidTypeForList(self, item):
        """
        isValidTypeForList(ListOfGlobalRenderInformation self, SBase item) -> bool


        Returns whether the given item can be added to this
        ListOfGlobalRenderInformation.

        Parameter 'item' is the SBase element to check.

        Returns 'True' if 'item' is not 'None,' and is of type
        SBML_RENDER_GLOBALRENDERINFORMATION; 'False' otherwise.

        """
        return _libsbml.ListOfGlobalRenderInformation_isValidTypeForList(self, item)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(ListOfGlobalRenderInformation self) -> bool


        Predicate returning 'True' if all the required attributes for this
        ListOfGlobalRenderInformation object have been set.

        Returns 'True' to indicate that all the required attributes of this
        ListOfGlobalRenderInformation have been set, otherwise 'False' is
        returned.

        """
        return _libsbml.ListOfGlobalRenderInformation_hasRequiredAttributes(self)


    def connectToChild(self):
        """
        connectToChild(ListOfGlobalRenderInformation self)


        Internal implementation method.

        """
        return _libsbml.ListOfGlobalRenderInformation_connectToChild(self)


    def getElementBySId(self, id):
        """
        getElementBySId(ListOfGlobalRenderInformation self, string id) -> SBase


        Returns the first child element that has the given 'id' in the model-
        wide SId namespace, or 'None' if no such object is found.

        Parameter 'id' is a string representing the id attribute of the object
        to retrieve.

        Returns a pointer to the SBase element with the given 'id'. If no such
        object is found, this method returns 'None.'

        """
        return _libsbml.ListOfGlobalRenderInformation_getElementBySId(self, id)


    def getElementByMetaId(self, metaid):
        """
        getElementByMetaId(ListOfGlobalRenderInformation self, string metaid) -> SBase


        Returns the first child element that has the given 'metaid', or 'None'
        if no such object is found.

        Parameter 'metaid' is a string representing the metaid attribute of
        the object to retrieve.

        Returns a pointer to the SBase element with the given 'metaid'. If no
        such object is found this method returns 'None.'

        """
        return _libsbml.ListOfGlobalRenderInformation_getElementByMetaId(self, metaid)


    def toXML(self):
        """
        toXML(ListOfGlobalRenderInformation self) -> XMLNode


        Creates an XMLNode object from this ListOfLocalRenderInformation
        object.

        Returns the XMLNode with the XML representation for the
        ListOfLocalRenderInformation object.

        """
        return _libsbml.ListOfGlobalRenderInformation_toXML(self)


    def parseXML(self, node):
        """
        parseXML(ListOfGlobalRenderInformation self, XMLNode node)


        Parses the xml information in the given node and sets the attributes.
        This method should never be called by the user. It is only used to
        read render information from annotations.

        Parameter 'node' is the XMLNode object reference that describes the
        ListOfGlobalRenderInformation object to be instantiated.

        """
        return _libsbml.ListOfGlobalRenderInformation_parseXML(self, node)

ListOfGlobalRenderInformation_swigregister = _libsbml.ListOfGlobalRenderInformation_swigregister
ListOfGlobalRenderInformation_swigregister(ListOfGlobalRenderInformation)

class ListOfGlobalStyles(ListOf):
    """

    [SBML 'render' package]

    A list of GlobalStyle objects.

    The ListOfGlobalStyles is a container for the GlobalStyle elements of
    a GlobalRenderInformation object.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    See also GlobalStyle.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfGlobalStyles, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfGlobalStyles, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ListOfGlobalStyles self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ListOfGlobalStyles
        __init__(ListOfGlobalStyles self, unsigned int level, unsigned int version) -> ListOfGlobalStyles
        __init__(ListOfGlobalStyles self, unsigned int level) -> ListOfGlobalStyles
        __init__(ListOfGlobalStyles self) -> ListOfGlobalStyles
        __init__(ListOfGlobalStyles self, RenderPkgNamespaces renderns) -> ListOfGlobalStyles
        __init__(ListOfGlobalStyles self, XMLNode node) -> ListOfGlobalStyles
        __init__(ListOfGlobalStyles self, ListOfGlobalStyles orig) -> ListOfGlobalStyles


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfGlobalStyles(long level =
        RenderExtension.getDefaultLevel(), long version =
        RenderExtension.getDefaultVersion(), long pkgVersion =
        RenderExtension.getDefaultPackageVersion())

        Creates a new ListOfGlobalStyles using the given SBML Level, Version
        and "render" package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        ListOfGlobalStyles.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this ListOfGlobalStyles.

        Parameter 'pkgVersion' is a long integer, the SBML Render Version to
        assign to this ListOfGlobalStyles.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfGlobalStyles(XMLNode node)

        Creates a new ListOfGlobalStyles object from the given XMLNode object.
        The XMLNode object has to contain a valid XML representation of a
        ListOfGlobalStyles object as defined in the render extension
        specification. This method is normally called when render information
        is read from a file and should normally not have to be called
        explicitly.

        Parameter 'node' is the XMLNode object reference that describes the
        ListOfGlobalStyles object to be instantiated.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfGlobalStyles(RenderPkgNamespaces renderns)

        Creates a new ListOfGlobalStyles using the given RenderPkgNamespaces
        object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'renderns' is the RenderPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfGlobalStyles(ListOfGlobalStyles orig)

        Copy constructor for ListOfGlobalStyles.

        Parameter 'orig' is the ListOfGlobalStyles instance to copy.

        """
        this = _libsbml.new_ListOfGlobalStyles(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ListOfGlobalStyles self) -> ListOfGlobalStyles


        Creates and returns a deep copy of this ListOfGlobalStyles object.

        Returns a (deep) copy of this ListOfGlobalStyles object.

        """
        return _libsbml.ListOfGlobalStyles_clone(self)

    __swig_destroy__ = _libsbml.delete_ListOfGlobalStyles
    __del__ = lambda self: None

    def get(self, *args):
        """
        get(ListOfGlobalStyles self, unsigned int n) -> GlobalStyle
        get(ListOfGlobalStyles self, unsigned int n) -> GlobalStyle
        get(ListOfGlobalStyles self, string sid) -> GlobalStyle
        get(ListOfGlobalStyles self, string sid) -> GlobalStyle


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a GlobalStyle from the ListOfGlobalStyles.

        Parameter 'n' is a long integer representing the index of the
        GlobalStyle to retrieve.

        Returns the nth GlobalStyle in this ListOfGlobalStyles. If the index
        'n' is invalid, 'None' is returned.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addGlobalStyle(), createGlobalStyle(), get(),
        getNumGlobalStyles(), remove(), remove().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a GlobalStyle from the ListOfGlobalStyles based on its identifier.

        Parameter 'sid' is a string representing the identifier of the
        GlobalStyle to retrieve.

        Returns the GlobalStyle in this ListOfGlobalStyles with the given
        'sid' or 'None' if no such GlobalStyle exists.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addGlobalStyle(), createGlobalStyle(), get(),
        getNumGlobalStyles(), remove(), remove().

        """
        return _libsbml.ListOfGlobalStyles_get(self, *args)


    def remove(self, *args):
        """
        remove(ListOfGlobalStyles self, unsigned int n) -> GlobalStyle
        remove(ListOfGlobalStyles self, string sid) -> GlobalStyle


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth GlobalStyle from this ListOfGlobalStyles and returns a
        pointer to it.

        Parameter 'n' is a long integer representing the index of the
        GlobalStyle to remove.

        Returns a pointer to the nth GlobalStyle in this ListOfGlobalStyles.

        WARNING:

        The pointer that is returned by this function is owned by the caller,
        who is responsible for deleting it.  Any changes made to the element
        will not be reflected in any resulting SBML document unless the
        element is added to an SBML Document.  Even in this case, the
        element's deletion is still the responsibility of the caller with two
        exceptions: if it is used as the 'disownedItem' in the
        ListOf.appendAndOwn() or ListOf.insertAndOwn()  functions.  All other
        functions in libsbml add a copy of the element, and do not transfer
        ownership of the pointer.

        See also addGlobalStyle(), createGlobalStyle(), get(), get(),
        getNumGlobalStyles(), remove().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes the GlobalStyle from this ListOfGlobalStyles based on its
        identifier and returns a pointer to it.

        Parameter 'sid' is a string representing the identifier of the
        GlobalStyle to remove.

        Returns the GlobalStyle in this ListOfGlobalStyles based on the
        identifier or None if no such GlobalStyle exists.

        WARNING:

        The pointer that is returned by this function is owned by the caller,
        who is responsible for deleting it.  Any changes made to the element
        will not be reflected in any resulting SBML document unless the
        element is added to an SBML Document.  Even in this case, the
        element's deletion is still the responsibility of the caller with two
        exceptions: if it is used as the 'disownedItem' in the
        ListOf.appendAndOwn() or ListOf.insertAndOwn()  functions.  All other
        functions in libsbml add a copy of the element, and do not transfer
        ownership of the pointer.

        See also addGlobalStyle(), createGlobalStyle(), get(), get(),
        getNumGlobalStyles(), remove().

        """
        return _libsbml.ListOfGlobalStyles_remove(self, *args)


    def addGlobalStyle(self, gs):
        """
        addGlobalStyle(ListOfGlobalStyles self, GlobalStyle gs) -> int


        Adds a copy of the given GlobalStyle to this ListOfGlobalStyles.

        Parameter 'gs' is the GlobalStyle object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_PKG_VERSION_MISMATCH

        * LIBSBML_DUPLICATE_OBJECT_ID

        Note: This method should be used with some caution.  The fact that
        this method copies the object passed to it means that the caller will
        be left holding a physically different object instance than the one
        contained inside this object.  Changes made to the original object
        instance (such as resetting attribute values) will not affect the
        instance in this object.  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 other methods on this class
        (particularly a corresponding method whose name begins with the word
        create) for alternatives that do not lead to these issues.

        See also createGlobalStyle(), get(), get(), getNumGlobalStyles(),
        remove(), remove().

        """
        return _libsbml.ListOfGlobalStyles_addGlobalStyle(self, gs)


    def getNumGlobalStyles(self):
        """
        getNumGlobalStyles(ListOfGlobalStyles self) -> unsigned int


        Get the number of GlobalStyle objects in this ListOfGlobalStyles.

        Returns the number of GlobalStyle objects in this ListOfGlobalStyles.

        See also addGlobalStyle(), createGlobalStyle(), get(), get(),
        remove(), remove().

        """
        return _libsbml.ListOfGlobalStyles_getNumGlobalStyles(self)


    def createGlobalStyle(self):
        """
        createGlobalStyle(ListOfGlobalStyles self) -> GlobalStyle


        Creates a new GlobalStyle object, adds it to this ListOfGlobalStyles
        object and returns the GlobalStyle object created.

        Returns a new GlobalStyle object instance.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addGlobalStyle(), get(), get(), getNumGlobalStyles(),
        remove(), remove().

        """
        return _libsbml.ListOfGlobalStyles_createGlobalStyle(self)


    def getElementName(self):
        """
        getElementName(ListOfGlobalStyles self) -> string


        Returns the XML element name of this ListOfGlobalStyles object.

        For ListOfGlobalStyles, the XML element name is always
        ''listOfGlobalStyles'.'

        Returns the name of this element, i.e. ''listOfGlobalStyles'.'

        """
        return _libsbml.ListOfGlobalStyles_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(ListOfGlobalStyles self) -> int


        Returns the libSBML type code for this ListOfGlobalStyles object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_LIST_OF.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        """
        return _libsbml.ListOfGlobalStyles_getTypeCode(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfGlobalStyles self) -> int


        Returns the libSBML type code for the SBML objects contained in this
        ListOfGlobalStyles object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML typecode for the objects contained in this
        ListOfGlobalStyles: SBML_RENDER_GLOBALSTYLE.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfGlobalStyles_getItemTypeCode(self)


    def toXML(self):
        """
        toXML(ListOfGlobalStyles self) -> XMLNode


        Creates an XMLNode object from this ListOfGlobalStyles object.

        Returns the XMLNode with the XML representation for the
        ListOfGlobalStyles object.

        """
        return _libsbml.ListOfGlobalStyles_toXML(self)

ListOfGlobalStyles_swigregister = _libsbml.ListOfGlobalStyles_swigregister
ListOfGlobalStyles_swigregister(ListOfGlobalStyles)

class ListOfGradientDefinitions(ListOf):
    """

    [SBML 'render' package]

    A list of GradientBase objects.

    The ListOfGradientDefinitions is a container for the GradientBase
    elements  of a RenderInformationBase object.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    See also GradientBase.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfGradientDefinitions, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfGradientDefinitions, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ListOfGradientDefinitions self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ListOfGradientDefinitions
        __init__(ListOfGradientDefinitions self, unsigned int level, unsigned int version) -> ListOfGradientDefinitions
        __init__(ListOfGradientDefinitions self, unsigned int level) -> ListOfGradientDefinitions
        __init__(ListOfGradientDefinitions self) -> ListOfGradientDefinitions
        __init__(ListOfGradientDefinitions self, RenderPkgNamespaces renderns) -> ListOfGradientDefinitions
        __init__(ListOfGradientDefinitions self, XMLNode node, unsigned int l2version=4) -> ListOfGradientDefinitions
        __init__(ListOfGradientDefinitions self, XMLNode node) -> ListOfGradientDefinitions
        __init__(ListOfGradientDefinitions self, ListOfGradientDefinitions orig) -> ListOfGradientDefinitions


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfGradientDefinitions( long level =
        RenderExtension.getDefaultLevel(), long version =
        RenderExtension.getDefaultVersion(), long pkgVersion =
        RenderExtension.getDefaultPackageVersion())

        Creates a new ListOfGradientDefinitions using the given SBML Level,
        Version and "render" package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        ListOfGradientDefinitions.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this ListOfGradientDefinitions.

        Parameter 'pkgVersion' is a long integer, the SBML Render Version to
        assign to this ListOfGradientDefinitions.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfGradientDefinitions(RenderPkgNamespaces renderns)

        Creates a new ListOfGradientDefinitions using the given
        RenderPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'renderns' is the RenderPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfGradientDefinitions(XMLNode node, long l2version=4)

        Creates a new ListOfGradientDefinitions object from the given XMLNode
        object. The XMLNode object has to contain a valid XML representation
        of a  ListOfGradientDefinitions object as defined in the render
        extension specification. This method is normally called when render
        information is read from a file and  should normally not have to be
        called explicitly.

        Parameter 'node' is the XMLNode object reference that describes the
        ListOfGradientDefinitions object to be instantiated.

        Parameter 'l2version' is an integer indicating the version of SBML
        Level 2

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfGradientDefinitions(ListOfGradientDefinitions orig)

        Copy constructor for ListOfGradientDefinitions.

        Parameter 'orig' is the ListOfGradientDefinitions instance to copy.

        """
        this = _libsbml.new_ListOfGradientDefinitions(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ListOfGradientDefinitions self) -> ListOfGradientDefinitions


        Creates and returns a deep copy of this ListOfGradientDefinitions
        object.

        Returns a (deep) copy of this ListOfGradientDefinitions object.

        """
        return _libsbml.ListOfGradientDefinitions_clone(self)

    __swig_destroy__ = _libsbml.delete_ListOfGradientDefinitions
    __del__ = lambda self: None

    def get(self, *args):
        """
        get(ListOfGradientDefinitions self, unsigned int n) -> GradientBase
        get(ListOfGradientDefinitions self, unsigned int n) -> GradientBase
        get(ListOfGradientDefinitions self, string sid) -> GradientBase
        get(ListOfGradientDefinitions self, string sid) -> GradientBase


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a GradientBase from the ListOfGradientDefinitions.

        Parameter 'n' is a long integer representing the index of the
        GradientBase to retrieve.

        Returns the nth GradientBase in this ListOfGradientDefinitions. If the
        index 'n' is invalid, 'None' is returned.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addGradientBase(), createLinearGradient(),
        createRadialGradient, get(), getNumGradientBases(), remove(),
        remove().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a GradientBase from the ListOfGradientDefinitions based on its
        identifier.

        Parameter 'sid' is a string representing the identifier of the
        GradientBase to retrieve.

        Returns the GradientBase in this ListOfGradientDefinitions with the
        given 'sid' or 'None' if no such GradientBase exists.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addGradientBase(), createLinearGradient(),
        createRadialGradient, get(), getNumGradientBases(), remove(),
        remove().

        """
        return _libsbml.ListOfGradientDefinitions_get(self, *args)


    def remove(self, *args):
        """
        remove(ListOfGradientDefinitions self, unsigned int n) -> GradientBase
        remove(ListOfGradientDefinitions self, string sid) -> GradientBase


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth GradientBase from this ListOfGradientDefinitions and
        returns a pointer to it.

        Parameter 'n' is a long integer representing the index of the
        GradientBase to remove.

        Returns a pointer to the nth GradientBase in this
        ListOfGradientDefinitions.

        WARNING:

        The pointer that is returned by this function is owned by the caller,
        who is responsible for deleting it.  Any changes made to the element
        will not be reflected in any resulting SBML document unless the
        element is added to an SBML Document.  Even in this case, the
        element's deletion is still the responsibility of the caller with two
        exceptions: if it is used as the 'disownedItem' in the
        ListOf.appendAndOwn() or ListOf.insertAndOwn()  functions.  All other
        functions in libsbml add a copy of the element, and do not transfer
        ownership of the pointer.

        See also addGradientBase(), createLinearGradient(),
        createRadialGradient, get(), get(), getNumGradientBases(), remove().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes the GradientBase from this ListOfGradientDefinitions based on
        its identifier and returns a pointer to it.

        Parameter 'sid' is a string representing the identifier of the
        GradientBase to remove.

        Returns the GradientBase in this ListOfGradientDefinitions based on
        the identifier or None if no such GradientBase exists.

        WARNING:

        The pointer that is returned by this function is owned by the caller,
        who is responsible for deleting it.  Any changes made to the element
        will not be reflected in any resulting SBML document unless the
        element is added to an SBML Document.  Even in this case, the
        element's deletion is still the responsibility of the caller with two
        exceptions: if it is used as the 'disownedItem' in the
        ListOf.appendAndOwn() or ListOf.insertAndOwn()  functions.  All other
        functions in libsbml add a copy of the element, and do not transfer
        ownership of the pointer.

        See also addGradientBase(), createLinearGradient(),
        createRadialGradient, get(), get(), getNumGradientBases(), remove().

        """
        return _libsbml.ListOfGradientDefinitions_remove(self, *args)


    def addGradientBase(self, gb):
        """
        addGradientBase(ListOfGradientDefinitions self, GradientBase gb) -> int


        Adds a copy of the given GradientBase to this
        ListOfGradientDefinitions.

        Parameter 'gb' is the GradientBase object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_PKG_VERSION_MISMATCH

        * LIBSBML_DUPLICATE_OBJECT_ID

        Note: This method should be used with some caution.  The fact that
        this method copies the object passed to it means that the caller will
        be left holding a physically different object instance than the one
        contained inside this object.  Changes made to the original object
        instance (such as resetting attribute values) will not affect the
        instance in this object.  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 other methods on this class
        (particularly a corresponding method whose name begins with the word
        create) for alternatives that do not lead to these issues.

        See also createLinearGradient(), createRadialGradient, get(), get(),
        getNumGradientBases(), remove(), remove().

        """
        return _libsbml.ListOfGradientDefinitions_addGradientBase(self, gb)


    def getNumGradientBases(self):
        """
        getNumGradientBases(ListOfGradientDefinitions self) -> unsigned int


        Get the number of GradientBase objects in this
        ListOfGradientDefinitions.

        Returns the number of GradientBase objects in this
        ListOfGradientDefinitions.

        See also addGradientBase(), createLinearGradient(),
        createRadialGradient, get(), get(), remove(), remove().

        """
        return _libsbml.ListOfGradientDefinitions_getNumGradientBases(self)


    def createLinearGradient(self):
        """
        createLinearGradient(ListOfGradientDefinitions self) -> LinearGradient


        Creates a new LinearGradient object, adds it to this
        ListOfGradientDefinitions object and returns the LinearGradient object
        created.

        Returns a new LinearGradient object instance.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addGradientBase(), get(), get(), getNumGradientBases(),
        remove(), remove().

        """
        return _libsbml.ListOfGradientDefinitions_createLinearGradient(self)


    def createRadialGradient(self):
        """
        createRadialGradient(ListOfGradientDefinitions self) -> RadialGradient


        Creates a new RadialGradient object, adds it to this
        ListOfGradientDefinitions object and returns the RadialGradient object
        created.

        Returns a new RadialGradient object instance.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addGradientBase(), get(), get(), getNumGradientBases(),
        remove(), remove().

        """
        return _libsbml.ListOfGradientDefinitions_createRadialGradient(self)


    def getElementName(self):
        """
        getElementName(ListOfGradientDefinitions self) -> string


        Returns the XML element name of this ListOfGradientDefinitions object.

        For ListOfGradientDefinitions, the XML element name is always
        ''listOfGradientDefinitions'.'

        Returns the name of this element, i.e. ''listOfGradientDefinitions'.'

        """
        return _libsbml.ListOfGradientDefinitions_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(ListOfGradientDefinitions self) -> int


        Returns the libSBML type code for this ListOfGradientDefinitions
        object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_LIST_OF.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        """
        return _libsbml.ListOfGradientDefinitions_getTypeCode(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfGradientDefinitions self) -> int


        Returns the libSBML type code for the SBML objects contained in this
        ListOfGradientDefinitions object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML typecode for the objects contained in this
        ListOfGradientDefinitions: SBML_RENDER_GRADIENTDEFINITION.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfGradientDefinitions_getItemTypeCode(self)


    def toXML(self):
        """
        toXML(ListOfGradientDefinitions self) -> XMLNode


        Creates an XMLNode object from this ListOfGradientDefinitions object.

        Returns the XMLNode with the XML representation for the
        ListOfGradientDefinitions object.

        """
        return _libsbml.ListOfGradientDefinitions_toXML(self)

ListOfGradientDefinitions_swigregister = _libsbml.ListOfGradientDefinitions_swigregister
ListOfGradientDefinitions_swigregister(ListOfGradientDefinitions)

class ListOfGradientStops(ListOf):
    """

    [SBML 'render' package]

    A list of one or more GradientStop objects.

    The ListOfGradientStops is used in linear and radial gradient objects
    to store the GradientStop objects that define the gradient. A valid
    gradient should have two or more gradient stops.

    The ListOfGradientStops is a container for the GradientStop elements
    of a GradientBase object.

    Note that the ListOfGradientStops class is only defined in libsbml for
    convenience: GradientStop objects are actually direct children of
    GradientBase-derived objects (i.e., LinearGradient or RadialGradient
    objects).

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    This class of objects is defined by libSBML only and has no direct
    equivalent in terms of SBML components.  This class is not prescribed
    by the SBML specifications, although it is used to implement features
    defined in SBML.

    See also GradientStop, GradientBase, LinearGradient, RadialGradient.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfGradientStops, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfGradientStops, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ListOfGradientStops self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ListOfGradientStops
        __init__(ListOfGradientStops self, unsigned int level, unsigned int version) -> ListOfGradientStops
        __init__(ListOfGradientStops self, unsigned int level) -> ListOfGradientStops
        __init__(ListOfGradientStops self) -> ListOfGradientStops
        __init__(ListOfGradientStops self, RenderPkgNamespaces renderns) -> ListOfGradientStops
        __init__(ListOfGradientStops self, XMLNode node, unsigned int l2version=4) -> ListOfGradientStops
        __init__(ListOfGradientStops self, XMLNode node) -> ListOfGradientStops
        __init__(ListOfGradientStops self, ListOfGradientStops orig) -> ListOfGradientStops


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfGradientStops(long level =
        RenderExtension.getDefaultLevel(), long version =
        RenderExtension.getDefaultVersion(), long pkgVersion =
        RenderExtension.getDefaultPackageVersion())

        Creates a new ListOfGradientStops using the given SBML Level, Version
        and "render" package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        ListOfGradientStops.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this ListOfGradientStops.

        Parameter 'pkgVersion' is a long integer, the SBML Render Version to
        assign to this ListOfGradientStops.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfGradientStops(XMLNode node, long l2version=4)

        Creates a new ListOfGradientStops object from the given XMLNode
        object. The XMLNode object has to contain a valid XML representation
        of a  ListOfGradientStops object as defined in the render extension
        specification. This method is normally called when render information
        is read from a file and  should normally not have to be called
        explicitly.

        Parameter 'node' is the XMLNode object reference that describes the
        ListOfGradientStops object to be instantiated.

        Parameter 'l2version' is an integer indicating the version of SBML
        Level 2

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfGradientStops(RenderPkgNamespaces renderns)

        Creates a new ListOfGradientStops using the given RenderPkgNamespaces
        object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'renderns' is the RenderPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfGradientStops(ListOfGradientStops orig)

        Copy constructor for ListOfGradientStops.

        Parameter 'orig' is the ListOfGradientStops instance to copy.

        """
        this = _libsbml.new_ListOfGradientStops(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ListOfGradientStops self) -> ListOfGradientStops


        Creates and returns a deep copy of this ListOfGradientStops object.

        Returns a (deep) copy of this ListOfGradientStops object.

        """
        return _libsbml.ListOfGradientStops_clone(self)

    __swig_destroy__ = _libsbml.delete_ListOfGradientStops
    __del__ = lambda self: None

    def get(self, *args):
        """
        get(ListOfGradientStops self, unsigned int n) -> GradientStop
        get(ListOfGradientStops self, unsigned int n) -> GradientStop
        get(ListOfGradientStops self, string sid) -> GradientStop
        get(ListOfGradientStops self, string sid) -> GradientStop


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a GradientStop from the ListOfGradientStops.

        Parameter 'n' is a long integer representing the index of the
        GradientStop to retrieve.

        Returns the nth GradientStop in this ListOfGradientStops. If the index
        'n' is invalid, 'None' is returned.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addGradientStop(), createGradientStop(), get(),
        getNumGradientStops(), remove(), remove().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a GradientStop from the ListOfGradientStops based on its
        identifier.

        Parameter 'sid' is a string representing the identifier of the
        GradientStop to retrieve.

        Returns the GradientStop in this ListOfGradientStops with the given
        'sid' or 'None' if no such GradientStop exists.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addGradientStop(), createGradientStop(), get(),
        getNumGradientStops(), remove(), remove().

        """
        return _libsbml.ListOfGradientStops_get(self, *args)


    def remove(self, *args):
        """
        remove(ListOfGradientStops self, unsigned int n) -> GradientStop
        remove(ListOfGradientStops self, string sid) -> GradientStop


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth GradientStop from this ListOfGradientStops and returns
        a pointer to it.

        Parameter 'n' is a long integer representing the index of the
        GradientStop to remove.

        Returns a pointer to the nth GradientStop in this ListOfGradientStops.

        WARNING:

        The pointer that is returned by this function is owned by the caller,
        who is responsible for deleting it.  Any changes made to the element
        will not be reflected in any resulting SBML document unless the
        element is added to an SBML Document.  Even in this case, the
        element's deletion is still the responsibility of the caller with two
        exceptions: if it is used as the 'disownedItem' in the
        ListOf.appendAndOwn() or ListOf.insertAndOwn()  functions.  All other
        functions in libsbml add a copy of the element, and do not transfer
        ownership of the pointer.

        See also addGradientStop(), createGradientStop(), get(), get(),
        getNumGradientStops(), remove().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes the GradientStop from this ListOfGradientStops based on its
        identifier and returns a pointer to it.

        Parameter 'sid' is a string representing the identifier of the
        GradientStop to remove.

        Returns the GradientStop in this ListOfGradientStops based on the
        identifier or None if no such GradientStop exists.

        WARNING:

        The pointer that is returned by this function is owned by the caller,
        who is responsible for deleting it.  Any changes made to the element
        will not be reflected in any resulting SBML document unless the
        element is added to an SBML Document.  Even in this case, the
        element's deletion is still the responsibility of the caller with two
        exceptions: if it is used as the 'disownedItem' in the
        ListOf.appendAndOwn() or ListOf.insertAndOwn()  functions.  All other
        functions in libsbml add a copy of the element, and do not transfer
        ownership of the pointer.

        See also addGradientStop(), createGradientStop(), get(), get(),
        getNumGradientStops(), remove().

        """
        return _libsbml.ListOfGradientStops_remove(self, *args)


    def addGradientStop(self, gs):
        """
        addGradientStop(ListOfGradientStops self, GradientStop gs) -> int


        Adds a copy of the given GradientStop to this ListOfGradientStops.

        Parameter 'gs' is the GradientStop object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_PKG_VERSION_MISMATCH

        * LIBSBML_DUPLICATE_OBJECT_ID

        Note: This method should be used with some caution.  The fact that
        this method copies the object passed to it means that the caller will
        be left holding a physically different object instance than the one
        contained inside this object.  Changes made to the original object
        instance (such as resetting attribute values) will not affect the
        instance in this object.  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 other methods on this class
        (particularly a corresponding method whose name begins with the word
        create) for alternatives that do not lead to these issues.

        See also createGradientStop(), get(), get(), getNumGradientStops(),
        remove(), remove().

        """
        return _libsbml.ListOfGradientStops_addGradientStop(self, gs)


    def getNumGradientStops(self):
        """
        getNumGradientStops(ListOfGradientStops self) -> unsigned int


        Get the number of GradientStop objects in this ListOfGradientStops.

        Returns the number of GradientStop objects in this
        ListOfGradientStops.

        See also addGradientStop(), createGradientStop(), get(), get(),
        remove(), remove().

        """
        return _libsbml.ListOfGradientStops_getNumGradientStops(self)


    def createGradientStop(self):
        """
        createGradientStop(ListOfGradientStops self) -> GradientStop


        Creates a new GradientStop object, adds it to this ListOfGradientStops
        object and returns the GradientStop object created.

        Returns a new GradientStop object instance.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addGradientStop(), get(), get(), getNumGradientStops(),
        remove(), remove().

        """
        return _libsbml.ListOfGradientStops_createGradientStop(self)


    def getElementName(self):
        """
        getElementName(ListOfGradientStops self) -> string


        Returns the XML element name of this ListOfGradientStops object.

        For ListOfGradientStops, the XML element name is always
        ''listOfGradientStops'.'

        Returns the name of this element, i.e. ''listOfGradientStops'.'

        """
        return _libsbml.ListOfGradientStops_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(ListOfGradientStops self) -> int


        Returns the libSBML type code for this ListOfGradientStops object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_LIST_OF.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        """
        return _libsbml.ListOfGradientStops_getTypeCode(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfGradientStops self) -> int


        Returns the libSBML type code for the SBML objects contained in this
        ListOfGradientStops object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML typecode for the objects contained in this
        ListOfGradientStops: SBML_RENDER_GRADIENT_STOP.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfGradientStops_getItemTypeCode(self)


    def toXML(self):
        """
        toXML(ListOfGradientStops self) -> XMLNode


        Creates an XMLNode object from this ListOfGradientStops object.

        Returns the XMLNode with the XML representation for the
        ListOfGradientStops object.

        """
        return _libsbml.ListOfGradientStops_toXML(self)

ListOfGradientStops_swigregister = _libsbml.ListOfGradientStops_swigregister
ListOfGradientStops_swigregister(ListOfGradientStops)

class ListOfLineEndings(ListOf):
    """

    [SBML 'render' package]

    A list of LineEnding objects.

    The ListOfLineEndings is a container for the LineEnding elements  of a
    RenderInformationBase object. Each RenderInformation object that
    inherits from RenderInformationBase can contain its own
    ListOfLineEndings object.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    See also LineEnding, RenderInformationBase.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfLineEndings, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfLineEndings, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ListOfLineEndings self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ListOfLineEndings
        __init__(ListOfLineEndings self, unsigned int level, unsigned int version) -> ListOfLineEndings
        __init__(ListOfLineEndings self, unsigned int level) -> ListOfLineEndings
        __init__(ListOfLineEndings self) -> ListOfLineEndings
        __init__(ListOfLineEndings self, RenderPkgNamespaces renderns) -> ListOfLineEndings
        __init__(ListOfLineEndings self, XMLNode node, unsigned int l2version=4) -> ListOfLineEndings
        __init__(ListOfLineEndings self, XMLNode node) -> ListOfLineEndings
        __init__(ListOfLineEndings self, ListOfLineEndings orig) -> ListOfLineEndings


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfLineEndings(long level =
        RenderExtension.getDefaultLevel(), long version =
        RenderExtension.getDefaultVersion(), long pkgVersion =
        RenderExtension.getDefaultPackageVersion())

        Creates a new ListOfLineEndings using the given SBML Level, Version
        and "render" package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        ListOfLineEndings.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this ListOfLineEndings.

        Parameter 'pkgVersion' is a long integer, the SBML Render Version to
        assign to this ListOfLineEndings.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfLineEndings(XMLNode node, long l2version=4)

        Creates a new ListOfLineEndings object from the given XMLNode object.
        The XMLNode object has to contain a valid XML representation of a
        ListOfLineEndings object as defined in the render extension
        specification. This method is normally called when render information
        is read from a file and  should normally not have to be called
        explicitly.

        Parameter 'node' is the XMLNode object reference that describes the
        ListOfLineEndings object to be instantiated.

        Parameter 'l2version' is an integer indicating the version of SBML
        Level 2

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfLineEndings(RenderPkgNamespaces renderns)

        Creates a new ListOfLineEndings using the given RenderPkgNamespaces
        object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'renderns' is the RenderPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfLineEndings(ListOfLineEndings orig)

        Copy constructor for ListOfLineEndings.

        Parameter 'orig' is the ListOfLineEndings instance to copy.

        """
        this = _libsbml.new_ListOfLineEndings(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ListOfLineEndings self) -> ListOfLineEndings


        Creates and returns a deep copy of this ListOfLineEndings object.

        Returns a (deep) copy of this ListOfLineEndings object.

        """
        return _libsbml.ListOfLineEndings_clone(self)

    __swig_destroy__ = _libsbml.delete_ListOfLineEndings
    __del__ = lambda self: None

    def get(self, *args):
        """
        get(ListOfLineEndings self, unsigned int n) -> LineEnding
        get(ListOfLineEndings self, unsigned int n) -> LineEnding
        get(ListOfLineEndings self, string sid) -> LineEnding
        get(ListOfLineEndings self, string sid) -> LineEnding


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a LineEnding from the ListOfLineEndings.

        Parameter 'n' is a long integer representing the index of the
        LineEnding to retrieve.

        Returns the nth LineEnding in this ListOfLineEndings. If the index 'n'
        is invalid, 'None' is returned.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addLineEnding(), createLineEnding(), get(),
        getNumLineEndings(), remove(), remove().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a LineEnding from the ListOfLineEndings based on its identifier.

        Parameter 'sid' is a string representing the identifier of the
        LineEnding to retrieve.

        Returns the LineEnding in this ListOfLineEndings with the given 'sid'
        or 'None' if no such LineEnding exists.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addLineEnding(), createLineEnding(), get(),
        getNumLineEndings(), remove(), remove().

        """
        return _libsbml.ListOfLineEndings_get(self, *args)


    def remove(self, *args):
        """
        remove(ListOfLineEndings self, unsigned int n) -> LineEnding
        remove(ListOfLineEndings self, string sid) -> LineEnding


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth LineEnding from this ListOfLineEndings and returns a
        pointer to it.

        Parameter 'n' is a long integer representing the index of the
        LineEnding to remove.

        Returns a pointer to the nth LineEnding in this ListOfLineEndings.

        WARNING:

        The pointer that is returned by this function is owned by the caller,
        who is responsible for deleting it.  Any changes made to the element
        will not be reflected in any resulting SBML document unless the
        element is added to an SBML Document.  Even in this case, the
        element's deletion is still the responsibility of the caller with two
        exceptions: if it is used as the 'disownedItem' in the
        ListOf.appendAndOwn() or ListOf.insertAndOwn()  functions.  All other
        functions in libsbml add a copy of the element, and do not transfer
        ownership of the pointer.

        See also addLineEnding(), createLineEnding(), get(), get(),
        getNumLineEndings(), remove().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes the LineEnding from this ListOfLineEndings based on its
        identifier and returns a pointer to it.

        Parameter 'sid' is a string representing the identifier of the
        LineEnding to remove.

        Returns the LineEnding in this ListOfLineEndings based on the
        identifier or None if no such LineEnding exists.

        WARNING:

        The pointer that is returned by this function is owned by the caller,
        who is responsible for deleting it.  Any changes made to the element
        will not be reflected in any resulting SBML document unless the
        element is added to an SBML Document.  Even in this case, the
        element's deletion is still the responsibility of the caller with two
        exceptions: if it is used as the 'disownedItem' in the
        ListOf.appendAndOwn() or ListOf.insertAndOwn()  functions.  All other
        functions in libsbml add a copy of the element, and do not transfer
        ownership of the pointer.

        See also addLineEnding(), createLineEnding(), get(), get(),
        getNumLineEndings(), remove().

        """
        return _libsbml.ListOfLineEndings_remove(self, *args)


    def addLineEnding(self, le):
        """
        addLineEnding(ListOfLineEndings self, LineEnding le) -> int


        Adds a copy of the given LineEnding to this ListOfLineEndings.

        Parameter 'le' is the LineEnding object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_PKG_VERSION_MISMATCH

        * LIBSBML_DUPLICATE_OBJECT_ID

        Note: This method should be used with some caution.  The fact that
        this method copies the object passed to it means that the caller will
        be left holding a physically different object instance than the one
        contained inside this object.  Changes made to the original object
        instance (such as resetting attribute values) will not affect the
        instance in this object.  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 other methods on this class
        (particularly a corresponding method whose name begins with the word
        create) for alternatives that do not lead to these issues.

        See also createLineEnding(), get(), get(), getNumLineEndings(),
        remove(), remove().

        """
        return _libsbml.ListOfLineEndings_addLineEnding(self, le)


    def getNumLineEndings(self):
        """
        getNumLineEndings(ListOfLineEndings self) -> unsigned int


        Get the number of LineEnding objects in this ListOfLineEndings.

        Returns the number of LineEnding objects in this ListOfLineEndings.

        See also addLineEnding(), createLineEnding(), get(), get(), remove(),
        remove().

        """
        return _libsbml.ListOfLineEndings_getNumLineEndings(self)


    def createLineEnding(self):
        """
        createLineEnding(ListOfLineEndings self) -> LineEnding


        Creates a new LineEnding object, adds it to this ListOfLineEndings
        object and returns the LineEnding object created.

        Returns a new LineEnding object instance.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addLineEnding(), get(), get(), getNumLineEndings(), remove(),
        remove().

        """
        return _libsbml.ListOfLineEndings_createLineEnding(self)


    def getElementName(self):
        """
        getElementName(ListOfLineEndings self) -> string


        Returns the XML element name of this ListOfLineEndings object.

        For ListOfLineEndings, the XML element name is always
        ''listOfLineEndings'.'

        Returns the name of this element, i.e. ''listOfLineEndings'.'

        """
        return _libsbml.ListOfLineEndings_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(ListOfLineEndings self) -> int


        Returns the libSBML type code for this ListOfLineEndings object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_LIST_OF.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        """
        return _libsbml.ListOfLineEndings_getTypeCode(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfLineEndings self) -> int


        Returns the libSBML type code for the SBML objects contained in this
        ListOfLineEndings object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML typecode for the objects contained in this
        ListOfLineEndings: SBML_RENDER_LINEENDING.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfLineEndings_getItemTypeCode(self)


    def toXML(self):
        """
        toXML(ListOfLineEndings self) -> XMLNode


        Creates an XMLNode object from this ListOfLineEndings object.

        Returns the XMLNode with the XML representation for the
        ListOfLineEndings object.

        """
        return _libsbml.ListOfLineEndings_toXML(self)

ListOfLineEndings_swigregister = _libsbml.ListOfLineEndings_swigregister
ListOfLineEndings_swigregister(ListOfLineEndings)

class ListOfLocalRenderInformation(ListOf):
    """

    [SBML 'render' package]

    A list of LocalRenderInformation objects.

    The ListOfLocalRenderInformation is a container for the
    LocalRenderInformation elements of a RenderLayoutPlugin object.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    See also LocalRenderInformation, RenderLayoutPlugin.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfLocalRenderInformation, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfLocalRenderInformation, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ListOfLocalRenderInformation self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ListOfLocalRenderInformation
        __init__(ListOfLocalRenderInformation self, unsigned int level, unsigned int version) -> ListOfLocalRenderInformation
        __init__(ListOfLocalRenderInformation self, unsigned int level) -> ListOfLocalRenderInformation
        __init__(ListOfLocalRenderInformation self) -> ListOfLocalRenderInformation
        __init__(ListOfLocalRenderInformation self, RenderPkgNamespaces renderns) -> ListOfLocalRenderInformation
        __init__(ListOfLocalRenderInformation self, ListOfLocalRenderInformation orig) -> ListOfLocalRenderInformation


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfLocalRenderInformation( long level =
        RenderExtension.getDefaultLevel(), long version =
        RenderExtension.getDefaultVersion(), long pkgVersion =
        RenderExtension.getDefaultPackageVersion())

        Creates a new ListOfLocalRenderInformation using the given SBML Level,
        Version and "render" package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        ListOfLocalRenderInformation.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this ListOfLocalRenderInformation.

        Parameter 'pkgVersion' is a long integer, the SBML Render Version to
        assign to this ListOfLocalRenderInformation.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfLocalRenderInformation(RenderPkgNamespaces renderns)

        Creates a new ListOfLocalRenderInformation using the given
        RenderPkgNamespaces object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'renderns' is the RenderPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfLocalRenderInformation(ListOfLocalRenderInformation
        orig)

        Copy constructor for ListOfLocalRenderInformation.

        Parameter 'orig' is the ListOfLocalRenderInformation instance to copy.

        """
        this = _libsbml.new_ListOfLocalRenderInformation(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ListOfLocalRenderInformation self) -> ListOfLocalRenderInformation


        Creates and returns a deep copy of this ListOfLocalRenderInformation
        object.

        Returns a (deep) copy of this ListOfLocalRenderInformation object.

        """
        return _libsbml.ListOfLocalRenderInformation_clone(self)

    __swig_destroy__ = _libsbml.delete_ListOfLocalRenderInformation
    __del__ = lambda self: None

    def getMajorVersion(self):
        """
        getMajorVersion(ListOfLocalRenderInformation self) -> unsigned int


        Returns the value of the 'majorVersion' attribute of this
        ListOfLocalRenderInformation.

        Returns the value of the 'majorVersion' attribute of this
        ListOfLocalRenderInformation as a longeger.

        """
        return _libsbml.ListOfLocalRenderInformation_getMajorVersion(self)


    def getMinorVersion(self):
        """
        getMinorVersion(ListOfLocalRenderInformation self) -> unsigned int


        Returns the value of the 'minorVersion' attribute of this
        ListOfLocalRenderInformation.

        Returns the value of the 'minorVersion' attribute of this
        ListOfLocalRenderInformation as a longeger.

        """
        return _libsbml.ListOfLocalRenderInformation_getMinorVersion(self)


    def getVersionString(self):
        """
        getVersionString(ListOfLocalRenderInformation self) -> string


        Returns the version as a string.

        Returns the version of the LocalRenderInformation object as a string

        """
        return _libsbml.ListOfLocalRenderInformation_getVersionString(self)


    def isSetMajorVersion(self):
        """
        isSetMajorVersion(ListOfLocalRenderInformation self) -> bool


        Predicate returning 'True' if this ListOfLocalRenderInformation's
        'majorVersion' attribute is set.

        Returns 'True' if this ListOfLocalRenderInformation's 'majorVersion'
        attribute has been set, otherwise 'False' is returned.

        """
        return _libsbml.ListOfLocalRenderInformation_isSetMajorVersion(self)


    def isSetMinorVersion(self):
        """
        isSetMinorVersion(ListOfLocalRenderInformation self) -> bool


        Predicate returning 'True' if this ListOfLocalRenderInformation's
        'minorVersion' attribute is set.

        Returns 'True' if this ListOfLocalRenderInformation's 'minorVersion'
        attribute has been set, otherwise 'False' is returned.

        """
        return _libsbml.ListOfLocalRenderInformation_isSetMinorVersion(self)


    def isSetVersionMajor(self):
        """
        isSetVersionMajor(ListOfLocalRenderInformation self) -> bool


        Internal implementation method.

        """
        return _libsbml.ListOfLocalRenderInformation_isSetVersionMajor(self)


    def isSetVersionMinor(self):
        """
        isSetVersionMinor(ListOfLocalRenderInformation self) -> bool


        Internal implementation method.

        """
        return _libsbml.ListOfLocalRenderInformation_isSetVersionMinor(self)


    def setMajorVersion(self, majorVersion):
        """
        setMajorVersion(ListOfLocalRenderInformation self, unsigned int majorVersion) -> int


        Sets the value of the 'majorVersion' attribute of this
        ListOfLocalRenderInformation.

        Parameter 'majorVersion' is long value of the 'majorVersion' attribute
        to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.ListOfLocalRenderInformation_setMajorVersion(self, majorVersion)


    def setMinorVersion(self, minorVersion):
        """
        setMinorVersion(ListOfLocalRenderInformation self, unsigned int minorVersion) -> int


        Sets the value of the 'minorVersion' attribute of this
        ListOfLocalRenderInformation.

        Parameter 'minorVersion' is long value of the 'minorVersion' attribute
        to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.ListOfLocalRenderInformation_setMinorVersion(self, minorVersion)


    def setVersionMajor(self, majorVersion):
        """
        setVersionMajor(ListOfLocalRenderInformation self, unsigned int majorVersion) -> int


        Internal implementation method.

        """
        return _libsbml.ListOfLocalRenderInformation_setVersionMajor(self, majorVersion)


    def setVersionMinor(self, minorVersion):
        """
        setVersionMinor(ListOfLocalRenderInformation self, unsigned int minorVersion) -> int


        Internal implementation method.

        """
        return _libsbml.ListOfLocalRenderInformation_setVersionMinor(self, minorVersion)


    def setVersion(self, major, minor):
        """
        setVersion(ListOfLocalRenderInformation self, unsigned int major, unsigned int minor)


        Sets the version of the render information list. The version consists
        of a major and a minor version number.

        Parameter 'major' is major version number Parameter 'minor' is minor
        version number

        """
        return _libsbml.ListOfLocalRenderInformation_setVersion(self, major, minor)


    def unsetMajorVersion(self):
        """
        unsetMajorVersion(ListOfLocalRenderInformation self) -> int


        Unsets the value of the 'majorVersion' attribute of this
        ListOfLocalRenderInformation.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.ListOfLocalRenderInformation_unsetMajorVersion(self)


    def unsetMinorVersion(self):
        """
        unsetMinorVersion(ListOfLocalRenderInformation self) -> int


        Unsets the value of the 'minorVersion' attribute of this
        ListOfLocalRenderInformation.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.ListOfLocalRenderInformation_unsetMinorVersion(self)


    def unsetVersionMajor(self):
        """
        unsetVersionMajor(ListOfLocalRenderInformation self) -> int


        Internal implementation method.

        """
        return _libsbml.ListOfLocalRenderInformation_unsetVersionMajor(self)


    def unsetVersionMinor(self):
        """
        unsetVersionMinor(ListOfLocalRenderInformation self) -> int


        Internal implementation method.

        """
        return _libsbml.ListOfLocalRenderInformation_unsetVersionMinor(self)


    def getDefaultValues(self, *args):
        """
        getDefaultValues(ListOfLocalRenderInformation self) -> DefaultValues
        getDefaultValues(ListOfLocalRenderInformation self) -> DefaultValues


        Returns the value of the 'defaultValues' element of this
        ListOfLocalRenderInformation.

        Returns the value of the 'defaultValues' element of this
        ListOfLocalRenderInformation as a DefaultValues.

        """
        return _libsbml.ListOfLocalRenderInformation_getDefaultValues(self, *args)


    def isSetDefaultValues(self):
        """
        isSetDefaultValues(ListOfLocalRenderInformation self) -> bool


        Predicate returning 'True' if this ListOfLocalRenderInformation's
        'defaultValues' element is set.

        Returns 'True' if this ListOfLocalRenderInformation's 'defaultValues'
        element has been set, otherwise 'False' is returned.

        """
        return _libsbml.ListOfLocalRenderInformation_isSetDefaultValues(self)


    def setDefaultValues(self, defaultValues):
        """
        setDefaultValues(ListOfLocalRenderInformation self, DefaultValues defaultValues) -> int


        Sets the value of the 'defaultValues' element of this
        ListOfLocalRenderInformation.

        Parameter 'defaultValues' is DefaultValues value of the
        'defaultValues' element to be set.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_INVALID_ATTRIBUTE_VALUE

        """
        return _libsbml.ListOfLocalRenderInformation_setDefaultValues(self, defaultValues)


    def createDefaultValues(self):
        """
        createDefaultValues(ListOfLocalRenderInformation self) -> DefaultValues


        Creates a new DefaultValues object, adds it to this
        ListOfLocalRenderInformation object and returns the DefaultValues
        object created.

        Returns a new DefaultValues object instance.

        """
        return _libsbml.ListOfLocalRenderInformation_createDefaultValues(self)


    def unsetDefaultValues(self):
        """
        unsetDefaultValues(ListOfLocalRenderInformation self) -> int


        Unsets the value of the 'defaultValues' element of this
        ListOfLocalRenderInformation.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        """
        return _libsbml.ListOfLocalRenderInformation_unsetDefaultValues(self)


    def get(self, *args):
        """
        get(ListOfLocalRenderInformation self, unsigned int n) -> LocalRenderInformation
        get(ListOfLocalRenderInformation self, unsigned int n) -> LocalRenderInformation
        get(ListOfLocalRenderInformation self, string sid) -> LocalRenderInformation
        get(ListOfLocalRenderInformation self, string sid) -> LocalRenderInformation


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a LocalRenderInformation from the ListOfLocalRenderInformation.

        Parameter 'n' is a long integer representing the index of the
        LocalRenderInformation to retrieve.

        Returns the nth LocalRenderInformation in this
        ListOfLocalRenderInformation. If the index 'n' is invalid, 'None' is
        returned.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addLocalRenderInformation(), createLocalRenderInformation(),
        get(), getNumLocalRenderInformation(), remove(), remove().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a LocalRenderInformation from the ListOfLocalRenderInformation
        based on its identifier.

        Parameter 'sid' is a string representing the identifier of the
        LocalRenderInformation to retrieve.

        Returns the LocalRenderInformation in this
        ListOfLocalRenderInformation with the given 'sid' or 'None' if no such
        LocalRenderInformation exists.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addLocalRenderInformation(), createLocalRenderInformation(),
        get(), getNumLocalRenderInformation(), remove(), remove().

        """
        return _libsbml.ListOfLocalRenderInformation_get(self, *args)


    def remove(self, *args):
        """
        remove(ListOfLocalRenderInformation self, unsigned int n) -> LocalRenderInformation
        remove(ListOfLocalRenderInformation self, string sid) -> LocalRenderInformation


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth LocalRenderInformation from this
        ListOfLocalRenderInformation and returns a pointer to it.

        Parameter 'n' is a long integer representing the index of the
        LocalRenderInformation to remove.

        Returns a pointer to the nth LocalRenderInformation in this
        ListOfLocalRenderInformation.

        WARNING:

        The pointer that is returned by this function is owned by the caller,
        who is responsible for deleting it.  Any changes made to the element
        will not be reflected in any resulting SBML document unless the
        element is added to an SBML Document.  Even in this case, the
        element's deletion is still the responsibility of the caller with two
        exceptions: if it is used as the 'disownedItem' in the
        ListOf.appendAndOwn() or ListOf.insertAndOwn()  functions.  All other
        functions in libsbml add a copy of the element, and do not transfer
        ownership of the pointer.

        See also addLocalRenderInformation(), createLocalRenderInformation(),
        get(), get(), getNumLocalRenderInformation(), remove().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes the LocalRenderInformation from this
        ListOfLocalRenderInformation based on its identifier and returns a
        pointer to it.

        Parameter 'sid' is a string representing the identifier of the
        LocalRenderInformation to remove.

        Returns the LocalRenderInformation in this
        ListOfLocalRenderInformation based on the identifier or None if no
        such LocalRenderInformation exists.

        WARNING:

        The pointer that is returned by this function is owned by the caller,
        who is responsible for deleting it.  Any changes made to the element
        will not be reflected in any resulting SBML document unless the
        element is added to an SBML Document.  Even in this case, the
        element's deletion is still the responsibility of the caller with two
        exceptions: if it is used as the 'disownedItem' in the
        ListOf.appendAndOwn() or ListOf.insertAndOwn()  functions.  All other
        functions in libsbml add a copy of the element, and do not transfer
        ownership of the pointer.

        See also addLocalRenderInformation(), createLocalRenderInformation(),
        get(), get(), getNumLocalRenderInformation(), remove().

        """
        return _libsbml.ListOfLocalRenderInformation_remove(self, *args)


    def addLocalRenderInformation(self, lri):
        """
        addLocalRenderInformation(ListOfLocalRenderInformation self, LocalRenderInformation lri) -> int


        Adds a copy of the given LocalRenderInformation to this
        ListOfLocalRenderInformation.

        Parameter 'lri' is the LocalRenderInformation object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_PKG_VERSION_MISMATCH

        * LIBSBML_DUPLICATE_OBJECT_ID

        Note: This method should be used with some caution.  The fact that
        this method copies the object passed to it means that the caller will
        be left holding a physically different object instance than the one
        contained inside this object.  Changes made to the original object
        instance (such as resetting attribute values) will not affect the
        instance in this object.  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 other methods on this class
        (particularly a corresponding method whose name begins with the word
        create) for alternatives that do not lead to these issues.

        See also createLocalRenderInformation(), get(), get(),
        getNumLocalRenderInformation(), remove(), remove().

        """
        return _libsbml.ListOfLocalRenderInformation_addLocalRenderInformation(self, lri)


    def getNumLocalRenderInformation(self):
        """
        getNumLocalRenderInformation(ListOfLocalRenderInformation self) -> unsigned int


        Get the number of LocalRenderInformation objects in this
        ListOfLocalRenderInformation.

        Returns the number of LocalRenderInformation objects in this
        ListOfLocalRenderInformation.

        See also addLocalRenderInformation(), createLocalRenderInformation(),
        get(), get(), remove(), remove().

        """
        return _libsbml.ListOfLocalRenderInformation_getNumLocalRenderInformation(self)


    def createLocalRenderInformation(self):
        """
        createLocalRenderInformation(ListOfLocalRenderInformation self) -> LocalRenderInformation


        Creates a new LocalRenderInformation object, adds it to this
        ListOfLocalRenderInformation object and returns the
        LocalRenderInformation object created.

        Returns a new LocalRenderInformation object instance.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addLocalRenderInformation(), get(), get(),
        getNumLocalRenderInformation(), remove(), remove().

        """
        return _libsbml.ListOfLocalRenderInformation_createLocalRenderInformation(self)


    def getElementName(self):
        """
        getElementName(ListOfLocalRenderInformation self) -> string


        Returns the XML element name of this ListOfLocalRenderInformation
        object.

        For ListOfLocalRenderInformation, the XML element name is always
        ''listOfLocalRenderInformation'.'

        Returns the name of this element, i.e.
        ''listOfLocalRenderInformation'.'

        """
        return _libsbml.ListOfLocalRenderInformation_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(ListOfLocalRenderInformation self) -> int


        Returns the libSBML type code for this ListOfLocalRenderInformation
        object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_LIST_OF.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        """
        return _libsbml.ListOfLocalRenderInformation_getTypeCode(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfLocalRenderInformation self) -> int


        Returns the libSBML type code for the SBML objects contained in this
        ListOfLocalRenderInformation object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML typecode for the objects contained in this
        ListOfLocalRenderInformation: SBML_RENDER_LOCALRENDERINFORMATION.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfLocalRenderInformation_getItemTypeCode(self)


    def hasRequiredAttributes(self):
        """
        hasRequiredAttributes(ListOfLocalRenderInformation self) -> bool


        Predicate returning 'True' if all the required attributes for this
        ListOfLocalRenderInformation object have been set.

        Returns 'True' to indicate that all the required attributes of this
        ListOfLocalRenderInformation have been set, otherwise 'False' is
        returned.

        """
        return _libsbml.ListOfLocalRenderInformation_hasRequiredAttributes(self)


    def connectToChild(self):
        """
        connectToChild(ListOfLocalRenderInformation self)


        Internal implementation method.

        """
        return _libsbml.ListOfLocalRenderInformation_connectToChild(self)


    def getElementBySId(self, id):
        """
        getElementBySId(ListOfLocalRenderInformation self, string id) -> SBase


        Returns the first child element that has the given 'id' in the model-
        wide SId namespace, or 'None' if no such object is found.

        Parameter 'id' is a string representing the id attribute of the object
        to retrieve.

        Returns a pointer to the SBase element with the given 'id'. If no such
        object is found, this method returns 'None.'

        """
        return _libsbml.ListOfLocalRenderInformation_getElementBySId(self, id)


    def getElementByMetaId(self, metaid):
        """
        getElementByMetaId(ListOfLocalRenderInformation self, string metaid) -> SBase


        Returns the first child element that has the given 'metaid', or 'None'
        if no such object is found.

        Parameter 'metaid' is a string representing the metaid attribute of
        the object to retrieve.

        Returns a pointer to the SBase element with the given 'metaid'. If no
        such object is found this method returns 'None.'

        """
        return _libsbml.ListOfLocalRenderInformation_getElementByMetaId(self, metaid)


    def toXML(self):
        """
        toXML(ListOfLocalRenderInformation self) -> XMLNode


        Creates an XMLNode object from this ListOfLocalRenderInformation
        object.

        Returns the XMLNode with the XML representation for the
        ListOfLocalRenderInformation object.

        """
        return _libsbml.ListOfLocalRenderInformation_toXML(self)

ListOfLocalRenderInformation_swigregister = _libsbml.ListOfLocalRenderInformation_swigregister
ListOfLocalRenderInformation_swigregister(ListOfLocalRenderInformation)

class ListOfLocalStyles(ListOf):
    """

    [SBML 'render' package]

    A list of LocalStyle objects.

    The ListOfLocalStyles is a container for the LocalStyle elements  of a
    LocalRenderInformation object.

    The various ListOf___ classes in SBML are merely containers used for
    organizing the main components of an SBML model.  In libSBML's
    implementation, ListOf___ classes are derived from the intermediate
    utility class ListOf, which is not defined by the SBML specifications
    but serves as a useful programmatic construct.  ListOf is itself is in
    turn derived from SBase, which provides all of the various ListOf___
    classes with common features defined by the SBML specification, such
    as 'metaid' attributes and annotations.

    The relationship between the lists and the rest of an SBML model is
    illustrated by the following (for SBML Level 2 Version 4):

      <?xml version="1.0" encoding="UTF-8"?>
      <sbml xmlns="http://www.sbml.org/sbml/level3/version1/core" 
            level="3" version="1">
        <model id="My_Model">
          <listOfFunctionDefinitions>
            <functionDefinition> ... </functionDefinition> 
          </listOfFunctionDefinitions>
          <listOfUnitDefinitions>
            <unitDefinition> ... </unitDefinition> 
          </listOfUnitDefinitions>
          <listOfCompartments>
            <compartment> ... </compartment> 
          </listOfCompartments>
          <listOfSpecies>
            <species> ... </species> 
          </listOfSpecies>
          <listOfParameters>
            <parameter> ... </parameter> 
          </listOfParameters>
          <listOfInitialAssignments>
            <initialAssignment> ... </initialAssignment> 
          </listOfInitialAssignments>
          <listOfRules>
            ... elements of subclasses of Rule ...
          </listOfRules>
          <listOfConstraints>
            <constraint> ... </constraint> 
          </listOfConstraints>
          <listOfReactions>
            <reaction> ... </reaction> 
          </listOfReactions>
          <listOfEvents>
            <event> ... </event> 
          </listOfEvents>
        </model>
      </sbml>

    SBML Level 3 Version 1 has essentially the same structure as  Level
    2 Version 4, depicted above, but SBML Level 3  Version 2 allows
    containers to contain zero or more of the relevant object, instead of
    requiring at least one.  As such, libsbml will write out an
    otherwise-empty ListOf___ element that has any optional attribute set
    (such as 'id' or 'metaid'), that has an optional child (such  as a
    'notes' or 'annotation'), or that has attributes or children set from
    any SBML Level 3 package, whether or not the ListOf___ has  any other
    children.

    Readers may wonder about the motivations for using the ListOf___
    containers in SBML.  A simpler approach in XML might be to place the
    components all directly at the top level of the model definition.  The
    choice made in SBML is to group them within XML elements named after
    ListOfClassname, in part because it helps organize the components.
    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 also ListOfFunctionDefinitions, ListOfUnitDefinitions,
    ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments,
    ListOfSpecies, ListOfParameters, ListOfInitialAssignments,
    ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents.

    See also LocalStyle, LocalRenderInformation.

    """

    __swig_setmethods__ = {}
    for _s in [ListOf]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfLocalStyles, name, value)
    __swig_getmethods__ = {}
    for _s in [ListOf]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListOfLocalStyles, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ListOfLocalStyles self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> ListOfLocalStyles
        __init__(ListOfLocalStyles self, unsigned int level, unsigned int version) -> ListOfLocalStyles
        __init__(ListOfLocalStyles self, unsigned int level) -> ListOfLocalStyles
        __init__(ListOfLocalStyles self) -> ListOfLocalStyles
        __init__(ListOfLocalStyles self, RenderPkgNamespaces renderns) -> ListOfLocalStyles
        __init__(ListOfLocalStyles self, XMLNode node) -> ListOfLocalStyles
        __init__(ListOfLocalStyles self, ListOfLocalStyles orig) -> ListOfLocalStyles


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfLocalStyles(long level =
        RenderExtension.getDefaultLevel(), long version =
        RenderExtension.getDefaultVersion(), long pkgVersion =
        RenderExtension.getDefaultPackageVersion())

        Creates a new ListOfLocalStyles using the given SBML Level, Version
        and "render" package version.

        Parameter 'level' is a long integer, the SBML Level to assign to this
        ListOfLocalStyles.

        Parameter 'version' is a long integer, the SBML Version to assign to
        this ListOfLocalStyles.

        Parameter 'pkgVersion' is a long integer, the SBML Render Version to
        assign to this ListOfLocalStyles.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        Note: Owing to the way that language interfaces are created in
        libSBML, this documentation may show methods that define default
        values for parameters with text that has the form parameter = value.
        This is not to be intepreted as a Python keyword argument; the use of
        a parameter name followed by an equals sign followed by a value is
        only meant to indicate a default value if the argument is not provided
        at all.  It is not a keyword in the Python sense.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfLocalStyles(XMLNode node)

        Creates a new ListOfLocalStyles object from the given XMLNode object.
        The XMLNode object has to contain a valid XML representation of a
        ListOfLocalStyles object as defined in the render extension
        specification. This method is normally called when render information
        is read from a file and should normally not have to be called
        explicitly.

        Parameter 'node' is the XMLNode object reference that describes the
        ListOfLocalStyles object to be instantiated.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfLocalStyles(ListOfLocalStyles orig)

        Copy constructor for ListOfLocalStyles.

        Parameter 'orig' is the ListOfLocalStyles instance to copy.

        ______________________________________________________________________
        Method variant with the following signature:

            ListOfLocalStyles(RenderPkgNamespaces renderns)

        Creates a new ListOfLocalStyles using the given RenderPkgNamespaces
        object.

        The package namespaces object used in this constructor is derived
        from a SBMLNamespaces object, which encapsulates SBML
        Level/Version/namespaces information.  It is used to communicate the
        SBML Level, Version, and  package version and name information used in
        addition to SBML Level 3 Core.  A common approach to using libSBML's
        SBMLNamespaces facilities is to create an package namespace object
        somewhere in a program once, then hand that object as needed to object
        constructors of that package that accept it as and argument, such as
        this one.

        Parameter 'renderns' is the RenderPkgNamespaces object.

        Note: Attempting to add an object to an SBMLDocument having a
        different combination of SBML Level, Version and XML namespaces than
        the object itself will result in an error at the time a caller
        attempts to make the addition.  A parent object must have compatible
        Level, Version and XML namespaces.  (Strictly speaking, a parent may
        also have more XML namespaces than a child, but the reverse is not
        permitted.)  The restriction is necessary to ensure that an SBML model
        has a consistent overall structure.  This requires callers to manage
        their objects carefully, but the benefit is increased flexibility in
        how models can be created by permitting callers to create objects
        bottom-up if desired.  In situations where objects are not yet
        attached to parents (e.g., SBMLDocument), knowledge of the intented
        SBML Level and Version help libSBML determine such things as whether
        it is valid to assign a particular value to an attribute.  For
        packages, this means that the  parent object to which this package
        element is being added must have been created with the package
        namespace, or that the package namespace was added to it, even if that
        parent is not a package object itself.

        """
        this = _libsbml.new_ListOfLocalStyles(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self):
        """
        clone(ListOfLocalStyles self) -> ListOfLocalStyles


        Creates and returns a deep copy of this ListOfLocalStyles object.

        Returns a (deep) copy of this ListOfLocalStyles object.

        """
        return _libsbml.ListOfLocalStyles_clone(self)

    __swig_destroy__ = _libsbml.delete_ListOfLocalStyles
    __del__ = lambda self: None

    def get(self, *args):
        """
        get(ListOfLocalStyles self, unsigned int n) -> LocalStyle
        get(ListOfLocalStyles self, unsigned int n) -> LocalStyle
        get(ListOfLocalStyles self, string sid) -> LocalStyle
        get(ListOfLocalStyles self, string sid) -> LocalStyle


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            get(long n)

        Get a LocalStyle from the ListOfLocalStyles.

        Parameter 'n' is a long integer representing the index of the
        LocalStyle to retrieve.

        Returns the nth LocalStyle in this ListOfLocalStyles. If the index 'n'
        is invalid, 'None' is returned.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addLocalStyle(), createLocalStyle(), get(),
        getNumLocalStyles(), remove(), remove().

        ______________________________________________________________________
        Method variant with the following signature:

            get(string sid)

        Get a LocalStyle from the ListOfLocalStyles based on its identifier.

        Parameter 'sid' is a string representing the identifier of the
        LocalStyle to retrieve.

        Returns the LocalStyle in this ListOfLocalStyles with the given 'sid'
        or 'None' if no such LocalStyle exists.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addLocalStyle(), createLocalStyle(), get(),
        getNumLocalStyles(), remove(), remove().

        """
        return _libsbml.ListOfLocalStyles_get(self, *args)


    def remove(self, *args):
        """
        remove(ListOfLocalStyles self, unsigned int n) -> LocalStyle
        remove(ListOfLocalStyles self, string sid) -> LocalStyle


        This method has multiple variants; they differ in the arguments  they
        accept.  Each variant is described separately below.

        ______________________________________________________________________
        Method variant with the following signature:

            remove(long n)

        Removes the nth LocalStyle from this ListOfLocalStyles and returns a
        pointer to it.

        Parameter 'n' is a long integer representing the index of the
        LocalStyle to remove.

        Returns a pointer to the nth LocalStyle in this ListOfLocalStyles.

        WARNING:

        The pointer that is returned by this function is owned by the caller,
        who is responsible for deleting it.  Any changes made to the element
        will not be reflected in any resulting SBML document unless the
        element is added to an SBML Document.  Even in this case, the
        element's deletion is still the responsibility of the caller with two
        exceptions: if it is used as the 'disownedItem' in the
        ListOf.appendAndOwn() or ListOf.insertAndOwn()  functions.  All other
        functions in libsbml add a copy of the element, and do not transfer
        ownership of the pointer.

        See also addLocalStyle(), createLocalStyle(), get(), get(),
        getNumLocalStyles(), remove().

        ______________________________________________________________________
        Method variant with the following signature:

            remove(string sid)

        Removes the LocalStyle from this ListOfLocalStyles based on its
        identifier and returns a pointer to it.

        Parameter 'sid' is a string representing the identifier of the
        LocalStyle to remove.

        Returns the LocalStyle in this ListOfLocalStyles based on the
        identifier or None if no such LocalStyle exists.

        WARNING:

        The pointer that is returned by this function is owned by the caller,
        who is responsible for deleting it.  Any changes made to the element
        will not be reflected in any resulting SBML document unless the
        element is added to an SBML Document.  Even in this case, the
        element's deletion is still the responsibility of the caller with two
        exceptions: if it is used as the 'disownedItem' in the
        ListOf.appendAndOwn() or ListOf.insertAndOwn()  functions.  All other
        functions in libsbml add a copy of the element, and do not transfer
        ownership of the pointer.

        See also addLocalStyle(), createLocalStyle(), get(), get(),
        getNumLocalStyles(), remove().

        """
        return _libsbml.ListOfLocalStyles_remove(self, *args)


    def addLocalStyle(self, ls):
        """
        addLocalStyle(ListOfLocalStyles self, LocalStyle ls) -> int


        Adds a copy of the given LocalStyle to this ListOfLocalStyles.

        Parameter 'ls' is the LocalStyle object to add.

        Returns integer value indicating success/failure of the function.
        The possible values returned by this function are:

        * LIBSBML_OPERATION_SUCCESS

        * LIBSBML_OPERATION_FAILED

        * LIBSBML_INVALID_OBJECT

        * LIBSBML_LEVEL_MISMATCH

        * LIBSBML_VERSION_MISMATCH

        * LIBSBML_PKG_VERSION_MISMATCH

        * LIBSBML_DUPLICATE_OBJECT_ID

        Note: This method should be used with some caution.  The fact that
        this method copies the object passed to it means that the caller will
        be left holding a physically different object instance than the one
        contained inside this object.  Changes made to the original object
        instance (such as resetting attribute values) will not affect the
        instance in this object.  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 other methods on this class
        (particularly a corresponding method whose name begins with the word
        create) for alternatives that do not lead to these issues.

        See also createLocalStyle(), get(), get(), getNumLocalStyles(),
        remove(), remove().

        """
        return _libsbml.ListOfLocalStyles_addLocalStyle(self, ls)


    def getNumLocalStyles(self):
        """
        getNumLocalStyles(ListOfLocalStyles self) -> unsigned int


        Get the number of LocalStyle objects in this ListOfLocalStyles.

        Returns the number of LocalStyle objects in this ListOfLocalStyles.

        See also addLocalStyle(), createLocalStyle(), get(), get(), remove(),
        remove().

        """
        return _libsbml.ListOfLocalStyles_getNumLocalStyles(self)


    def createLocalStyle(self):
        """
        createLocalStyle(ListOfLocalStyles self) -> LocalStyle


        Creates a new LocalStyle object, adds it to this ListOfLocalStyles
        object and returns the LocalStyle object created.

        Returns a new LocalStyle object instance.

        Note: The pointer that is returned by this function is not owned by
        the caller, but may be queried and modified.  Any changes made will be
        reflected in any resulting SBML document containing the pointer's
        parent.

        See also addLocalStyle(), get(), get(), getNumLocalStyles(), remove(),
        remove().

        """
        return _libsbml.ListOfLocalStyles_createLocalStyle(self)


    def getElementName(self):
        """
        getElementName(ListOfLocalStyles self) -> string


        Returns the XML element name of this ListOfLocalStyles object.

        For ListOfLocalStyles, the XML element name is always
        ''listOfLocalStyles'.'

        Returns the name of this element, i.e. ''listOfLocalStyles'.'

        """
        return _libsbml.ListOfLocalStyles_getElementName(self)


    def getTypeCode(self):
        """
        getTypeCode(ListOfLocalStyles self) -> int


        Returns the libSBML type code for this ListOfLocalStyles object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML type code for this object: SBML_LIST_OF.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        """
        return _libsbml.ListOfLocalStyles_getTypeCode(self)


    def getItemTypeCode(self):
        """
        getItemTypeCode(ListOfLocalStyles self) -> int


        Returns the libSBML type code for the SBML objects contained in this
        ListOfLocalStyles object.

        LibSBML attaches an identifying code to every kind of SBML object.
        These are integer constants known as SBML type codes.  The names of
        all the codes begin with the characters SBML_. In the Python language
        interface for libSBML, the type codes are defined as static integer
        constants in the interface class 'libsbml'.  Note that different Level
        3 package plug-ins may use overlapping type codes; to identify the
        package to which a given object belongs, call the
        SBase.getPackageName()

        method on the object.

        The exception to this is lists:  all SBML-style list elements have the
        type  SBML_LIST_OF, regardless of what package they  are from.

        Returns the SBML typecode for the objects contained in this
        ListOfLocalStyles: SBML_RENDER_LOCALSTYLE.

        WARNING:

        The specific integer values of the possible type codes may be reused
        by different libSBML plug-ins for SBML Level 3. packages,  To fully
        identify the correct code, it is necessary to invoke both
        getPackageName() and getTypeCode() (or  ListOf.getItemTypeCode()).

        See also getElementName(), getPackageName().

        """
        return _libsbml.ListOfLocalStyles_getItemTypeCode(self)


    def toXML(self):
        """
        toXML(ListOfLocalStyles self) -> XMLNode


        Creates an XMLNode object from this ListOfLocalStyles object.

        Returns the XMLNode with the XML representation for the
        ListOfLocalStyles object.

        """
        return _libsbml.ListOfLocalStyles_toXML(self)

ListOfLocalStyles_swigregister = _libsbml.ListOfLocalStyles_swigregister
ListOfLocalStyles_swigregister(ListOfLocalStyles)

class StringSet(_object):
    """Proxy of C++ std::set<(std::string)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StringSet, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StringSet, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(std::set<(std::string)> self) -> StringSet
        __init__(std::set<(std::string)> self, StringSet arg2) -> StringSet
        """
        this = _libsbml.new_StringSet(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def size(self):
        """size(StringSet self) -> unsigned int"""
        return _libsbml.StringSet_size(self)


    def empty(self):
        """empty(StringSet self) -> bool"""
        return _libsbml.StringSet_empty(self)


    def clear(self):
        """clear(StringSet self)"""
        return _libsbml.StringSet_clear(self)


    def get(self, key):
        """get(StringSet self, string key) -> string"""
        return _libsbml.StringSet_get(self, key)


    def insert(self, key):
        """insert(StringSet self, string key)"""
        return _libsbml.StringSet_insert(self, key)


    def _del(self, key):
        """_del(StringSet self, string key)"""
        return _libsbml.StringSet__del(self, key)


    def has_key(self, key):
        """has_key(StringSet self, string key) -> bool"""
        return _libsbml.StringSet_has_key(self, key)

    __swig_destroy__ = _libsbml.delete_StringSet
    __del__ = lambda self: None
StringSet_swigregister = _libsbml.StringSet_swigregister
StringSet_swigregister(StringSet)

class double_array(_object):
    """Proxy of C++ double_array class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, double_array, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, double_array, name)
    __repr__ = _swig_repr

    def __init__(self, nelements):
        """__init__(double_array self, size_t nelements) -> double_array"""
        this = _libsbml.new_double_array(nelements)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_double_array
    __del__ = lambda self: None

    def __getitem__(self, index):
        """__getitem__(double_array self, size_t index) -> double"""
        return _libsbml.double_array___getitem__(self, index)


    def __setitem__(self, index, value):
        """__setitem__(double_array self, size_t index, double value)"""
        return _libsbml.double_array___setitem__(self, index, value)


    def cast(self):
        """cast(double_array self) -> double *"""
        return _libsbml.double_array_cast(self)


    def frompointer(t):
        """frompointer(double * t) -> double_array"""
        return _libsbml.double_array_frompointer(t)

    frompointer = staticmethod(frompointer)
double_array_swigregister = _libsbml.double_array_swigregister
double_array_swigregister(double_array)

def double_array_frompointer(t):
    """double_array_frompointer(double * t) -> double_array"""
    return _libsbml.double_array_frompointer(t)

class int_array(_object):
    """Proxy of C++ int_array class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, int_array, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, int_array, name)
    __repr__ = _swig_repr

    def __init__(self, nelements):
        """__init__(int_array self, size_t nelements) -> int_array"""
        this = _libsbml.new_int_array(nelements)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _libsbml.delete_int_array
    __del__ = lambda self: None

    def __getitem__(self, index):
        """__getitem__(int_array self, size_t index) -> int"""
        return _libsbml.int_array___getitem__(self, index)


    def __setitem__(self, index, value):
        """__setitem__(int_array self, size_t index, int value)"""
        return _libsbml.int_array___setitem__(self, index, value)


    def cast(self):
        """cast(int_array self) -> int *"""
        return _libsbml.int_array_cast(self)


    def frompointer(t):
        """frompointer(int * t) -> int_array"""
        return _libsbml.int_array_frompointer(t)

    frompointer = staticmethod(frompointer)
int_array_swigregister = _libsbml.int_array_swigregister
int_array_swigregister(int_array)

def int_array_frompointer(t):
    """int_array_frompointer(int * t) -> int_array"""
    return _libsbml.int_array_frompointer(t)

# This file is compatible with both classic and new-style classes.



global __version__
__version__ = '5.18.0'
